类库_c 开源跨平台类库集 - CSDN
  • 什么是类库

    2017-11-28 10:06:16
    一、类库项目 除了在项目中把类放在不同的文件中之外,还可以把它们放在完全不同的项目中。如果一个项目什么都不包含,只包含类(以及其他相关的类型定义,但没有入口点),该项目就称为类库类库项目编译为.dll ...

    一、类库项目

    除了在项目中把类放在不同的文件中之外,还可以把它们放在完全不同的项目中。如果一个项目什么都不包含,只包含类(以及其他相关的类型定义,但没有入口点),该项目就称为类库。

    类库项目编译为.dll 程序集,在其他项目中添加对类库项目的引用,就可以访问它的内容(这可以是同一个解决方案的一部分,但这不是必须的)。这将扩展对象提供的封装性,因为类库可以进行修改和更新,而不会影响使用它们的其他项目。这意味着,你可以方便地升级类提供的服务(这会影响多个用户应用程序)。

    二、接口和抽象类

    抽象类和接口都包含可以由派生类继承的成员。接口和抽象类都不能直接实例化,但可以声明这些类型的变量。如果这样做,就可以使用多态性把继承这两种类型的对象指定给它们的变量。接着通过这些变量来使用这些类型的成员,但不能直接访问派生对象的其他成员。

    区别:

    1.派生类只能继承一个基类,即只能直接继承一个抽象类(但可以用一个继承链包含多个抽象类)。相反,类可以使用任意多个接口。

    2.抽象类可以拥有抽象成员(没有代码体,且必须在派生类中实现,否则派生类本身必须也是抽象的)用非抽象成员(它们拥有代码体,也可以是虚拟的,这样就可以在派生类中重写)。

    3.接口成员必须都在使用接口的类上实现——它们没有代码体。另外,按照定义,接口成员是公共的(因为它们倾向于在外部使用),但抽象类的成员可以是私有的(只要它们不是抽象的)、受保护的、内部的或受保护的内部成员(其中受保护的内部成员只能在应用程序的代码或派生类中访问)。此外,接口不能包含字段、构造函数、析构函数、静态成员或常量。

    展开全文
  • Java类库大全

    2020-07-29 14:21:10
    Java类库大全,适合查阅使用,希望能给大家带来方便~
  • 自己最想详细整理了以前用到的一些常用的类库,其中包含各种数据库操作类,XMl,字符串操作,磁盘操作,文件操作等...上面都有注释,使用时添加一个AppRun.dll即可,自己也可以扩充,重新编译,便于理解有些函数名是...
  • 框架与类库

    2018-09-06 20:55:44
    架和类库等概念的出现都是源于人们对复用的渴望。“不要重复发明轮子”,成了软件界的一句经典名言。从最初的单个函数源代码的复用,到面向对象中类的复用(通常以类库的形式体现),再到基于组件编程中二进制组件...

     

    架和类库等概念的出现都是源于人们对复用的渴望。“不要重复发明轮子”,成了软件界的一句经典名言。从最初的单个函数源代码的复用,到面向对象中类的复用(通常以类库的形式体现),再到基于组件编程中二进制组件(.NET中是以IL程序集形式存在的)的复用,人们复用软件的抽象层次越来越高。现在,框架复用是抽象层次的又一提升,框架的复用不仅仅是功能的复用,更是设计的复用。

    1.1 框架与类库的区别

       我们先来简单说说什么是类库(Class Library)?望文生义,类库就是一些类的集合,只要我们将一些可以复用的类集中放到一个Library中,我们就可以称其为一个类库。类库中的许多元素(如类、结构、接口、枚举、委托等)之间可能有一些关联,但这些关联通常用于支持一个类概念或接口概念的完整表达。如果我们从一个更高的视角来审视类库,可以发现类库中的一个个“完整的概念”之间是无关的或是关系松散的。

       再来说框架,框架的第一含义是一个骨架,它封装了某领域内处理流程的控制逻辑,所以我们经常说框架是一个半成品的应用。由于领域的种类是如此众多,所以框架必须具有针对性,比如,专门用于解决底层通信的框架,或专门用于医疗领域的框架。框架中也包含了很多元素,但是这些元素之间关系的紧密程度要远远大于类库中元素之间的关系。框架中的所有元素都为了实现一个共同的目标而相互协作。

       没有一个万能的框架可以应用于所有种类的领域和应用,框架的目标性非常强,它专注于解决某一特定领域的问题,并致力于为这一特定领域提供通用的解决方案。

       框架与类库的区别主要表现在以下几个方面:
    (1)从结构上说,框架内部是高内聚的,而类库内部则是相对松散的。
    (2)框架封装了处理流程的控制逻辑,而类库几乎不涉及任何处理流程和控制逻辑。
       正是由于框架对处理流程的控制逻辑进行了封装,才使得框架成为一个应用的骨架。框架中的处理流程和控制逻辑需要经过精心的设计,因为所有使用了该框架的应用程序都会复用该设计。
    (3)框架具有IOC(控制反转)能力,而类库没有。   
       IOC,即俗称的好莱坞模式(Don’t call us, we will call you)。对于类库中的元素来说,通常都是由我们的应用来调用它;而框架具有这种能力――在适当的时候调用我们应用中的逻辑。这种能力是通过框架扩展点(或称为“插槽”)来做到的――具体的应用通过扩展点注入自己的逻辑,而在适当的时候,框架会调用这个扩展点中已注册的逻辑。实际上,.NET中的事件(event)发布、预定机制就是IOC的一个代表性例子。
    (4)框架专注于特定领域,而类库却是更通用的。
       框架着力于一个特定领域的解决方案的完整表达,而类库几乎不针对任何特定领域。比如,本书中提到的通信框架只适用于需要在TCP/UDP基础上直接构建通信的应用程序,而像正则表达式这样的类库却可以使用在各种不同的应用中。
    (5)框架通常建立在众多类库的基础之上,而类库一般不会依赖于某框架。

    1.2 通用框架与应用框架

          如果要对框架进行进一步分类,则可以根据框架针对的领域是否具有通用性而将它们分为通用框架(General Framework)和应用框架(Application Framework)。通用框架可以在不同类型的应用中使用,而应用框架只被使用于某一特定类型的应用中。
          比如,ORM框架NHibernate就是一个通用框架,该框架可以用于所有需要解决O/R映射的各种类型的应用中。而某个金融框架则是一个应用框架,它仅仅被用于金融类型的应用中。
          可以这么说,通用框架所解决的是所有类型的应用都关心的“普遍”问题,而应用框架解决的是某一特定类型的应用关心的问题。所以,如果我们需要将某种类型的应用的核心业务逻辑流程提升到一个框架中,所得到的这个框架就是一个应用框架。与通用框架相比,应用框架需要了解更多目标业务领域内的领域知识。
          在实现具体的应用程序时,可以采用一个应用框架与多个通用框架相结合的方式,这样有利于快速、高质量的应用程序开发。比如,某个金融领域的一个应用,可以采用金融框架作为应用框架来解决与金融业务逻辑相关的问题,采用Nhibernate解决数据访问,采用ESFramework解决应用中各分布式系统之间的通信。 

          下图描述了类库、框架和应用之间的层次关系。
    框架和类库的区别


       当然,一个应用也可以完全不采用任何框架,而是直接从最基础的底层API(如.NET Framework)开始构建。对于微型的系统,这种方式或许可行。但对于复杂大型的应用,困难度就可想而知了。

    1.3 框架之于应用

       当一个应用系统选定了框架之后,我们需要做的就是在框架提供扩展点的地方添加应用的具体逻辑,也就是使用“血”和“肉”来填充这个骨架从而得到一个“有机体”。
       由于框架通常都是在实践中经过反复使用和检验的,所以质量有一定的保证,这使得我们用更少的时间、更少的编码来实现一个更稳定的系统成为可能。当然,框架也不是“银弹”,它不能解决软件复杂性的根本问题,但是我们却通过它向这个终极的理想目标又迈进了一步。
       有一点需要注意,框架使得我们的系统在有所支撑的同时,它也给出了限制。因为通常当我们确定采用了某一个框架之后,我们就必须在这个框架限制的“框框”之内来构建我们的应用。大多数时候,这不是一个问题,但是如果因为框架的限制而严重影响了我们系统目标的实现的时候,我们就需要考虑是否应该放弃这个框架,或者换一个其它的同类型的框架。

    1.4 框架设计

       框架使得我们开发应用的速度更快、质量更高、成本更低,这些好处是不言而喻的。然而,面对万千变化日趋复杂的软件需求,设计和实现一个高度灵活可复用的框架又谈何容易!
       框架源于应用,却又高于应用。
       框架往往是这样产生的:我们拥有了开发某种类型应用的大量经验,我们总结这种类型的应用中共性的东西,将其提炼到一个高的层次中,以备复用。这个“高层次”的东西便是框架的原型。随着我们经验的不断积累,框架也会不断地完善、发展。
       框架是一个实践的产物,而不是在实验室中理论研究出来的。所以设计一个框架最好的方法就是从一个具体的应用开始,以提供同一类型应用的通用解决方案为目标,不断地从具体应用中提炼、萃取框架!然后在应用中使用这个框架,并在使用的过程中不断地修正和完善。
       有一点需要特别注意,正如所有的软件架构设计的要点在于权衡(在这方面有点像艺术),框架的设计也不例外,正如前面提到,框架在为应用提供了一个骨架的同时,也给我们的应用圈定了一个框框,我们只能在这个有限的天地内来发挥。所以,一个好的框架设计应当采用了一个非常恰当的权衡决策,以使框架在为我们应用提供强大支持的同时,而又对我们的应用作更少的限制。权衡,从来就不是一件简单的事情,但是有很多框架设计的经验可以供我们参考。

    1.4.1 框架设计经验、原则

    (1)框架不要为应用做过多的假设!     

       关于框架为应用做过多的假设,一个非常具体的现象就是,框架越俎代庖,把本来是应用要做的事情揽过来自己做。这是一种典型的吃力不讨好的做法。框架越俎代庖,也许会使得某一个具体应用的开发变得简单,却会给其它更多想使用该框架的应用增加了本没有必要的束缚和负担。

    (2)使用接口,保证框架提供的所有重要实现都是可以被替换的。

    框架终究不是应用,所以框架无法考虑所有应用的具体情况,保证所有重要的组件的实现都是可以被替换的,这一点非常重要,它使得应用可以根据当前的实际情况来替换掉框架提供的部分组件的默认实现。使用接口来定义框架中各个组件及组件间的联系,将提高框架的可复用性。

    (3)框架应当简洁、一致、且目标集中。

    框架应当简洁,不要包含那些对框架目标来说无关紧要的东西,保证框架中的每个组件的存在都是为了支持框架目标的实现。包含过多无谓的元素(类、接口、枚举等),会使框架变得难以理解,尝试将这些对于框架核心目标不太重要的元素转移到类库中,可以使得框架更清晰、目标更集中。

    (4)提供一个常用的骨架,但是不要固定骨架的结构,使骨架也是可以组装的。

    比如说,如果是针对某种业务处理的框架,那么框架不应该只提供一套不可变更的业务处理流程,而是应该将处理流程“单步”化,使得各个步骤是可以重新组装的,如此一来,应用便可以根据实际情况来改变框架默认的处理流程。这种框架的可定制化能力可以极大地提高框架的可复用性。

    (5)不断地重构框架。

       如果说设计和实现一个高质量的框架有什么秘诀?答案只有一个,重构、不断地重构。重构框架的实现代码、甚至重构框架的设计。重构的驱动力源于几个方面,比如对要解决的本质问题有了更清晰准备的认识,在使用框架的时候发现某些组件职责不明确、难以使用,框架的层次结构不够清晰等。

    1.4.2 如何称得上一个优秀的框架?

          一个优秀框架的最主要的特点是:简单。这种简单性不是轻而易举就可以获得的,正如优秀的框架不是一蹴而就的,达到这种简单性需要对框架不断地抽丝、不断地提炼和完善。简单的真正原因在于它抓住了要解决的问题的本质。一个优秀的框架通常都具有如下特点:

    (1)清晰的、简洁的、一致的。    

          “清晰”指的是框架的结构是清晰的、框架的层次是清晰明朗的、框架中各个类和组件的职责是清晰明确的。

    “简洁”指的是框架中没有无关紧要多余的元素,而且各个类和组件的职责目标是非常集中的,这正是“高内聚、低耦合”设计原则的体现。

    “一致”通常会带来这样的好处,框架的使用者在熟悉了框架的一部分后,会非常容易地理解框架的另一部分。“一致”通常体现在命名的规则一致、命名的含义一致、组件的装配方式和使用方式一致等。

    (2)易于使用的

          只有易于使用的框架才会走得更远。

       正是因为易于使用,框架使用者们才有可能试用这个框架,在试用满意后才有可能决定采用这个框架。一个框架功能即使再强大,如果难以使用,那么框架使用者们很可能根本就不会有试用这个框架的念头。

    框架的生命力源于框架一直在不断地完善和发展,如果没有人使用这个框架,这个框架便没有了发展和完善的源动力。正如友好的用户界面是优秀应用程序不可或缺的重要部分,易于使用也是优秀框架的一个重要特性。

    (3)高度可扩展的、灵活的

          框架通过高度可扩展性来应对应用程序的万千变化。

          没有任何一个框架可以预料所有应用的需求,万能的框架是不存在的。企图设计、实现一个万能框架的想法是荒诞的。框架必须具有“以不变应万变”的能力,框架可以通过为应用预留恰当的、足够的扩展点来做到这一点。

          框架的灵活体现在框架可以根据不同的应用进行不同的组装和配置,就像框架是专门为当前的应用所订制的一样。

    (4)轻量的

          “轻量”,说的通俗点,就是只为自己需要使用的服务付费,而不需要为自己不需要的服务买单。一个重量级的框架有一个很明显的特征就是,如果你需要一套完整的套餐服务,那是没有问题的,框架可以很好的满足你;但是,如果你只需要这份套餐中的一小块点心,对不起,框架仍然会强加一个完整的套餐给你,你必须付一整份套餐的费用。
       优秀的框架应当支持使用者“按需所取”的原则,框架使用者可以随意“点菜”进行组装来满足自己的需求。

    (5)弱侵入性的

          所谓“弱侵入性”,采用了框架的应用程序可以尽可能的以普通的方式来编写应用逻辑,而不必为了适应框架不得不使用一些特殊的手法。

       这可能有点难以理解,我们可以举个例子来简单说明。在.NET中,实现AOP(面向方面编程)机制的两种主要方式是使用Proxy和动态代理。使用Proxy实现的AOP框架通常要求那些需要使用AOP截获功能的类必须继承自ContexBoundObject;而采用动态代理实现的AOP框架则没有任何如此侵入性的要求,我们仍可以以最普通的方式来编写应用逻辑类,这类框架会在运行时根据配置动态地生成目标对象的代理对象来实现AOP截获。所以我们可以说,采用动态代理方式实现的AOP框架相比采用Proxy实现的AOP框架,具有更弱的侵入性。

       弱侵入性意味着框架对应用逻辑的干扰更少,由于应用逻辑类都是普通的类,这非常方便应用逻辑在另外一个程序中复用,而另外的程序可能采用了一个完全不同的框架。

     

    原文:    http://blog.sina.com.cn/zhaoxiaobo12

    展开全文
  • 类库

    2020-01-17 13:58:12
    目录 1.基本类型 2.默认方法 2.1 接口的继承 2.2 多重继承 3.内置函数式接口 ...前面讨论了如何编写 Lambda 表达式, 接下来将详细阐述另一个重要方面: 如何使用Lambda 表达式。 即使不需要编写像 S...

    目录

    1.基本类型

    2.默认方法

    2.1 接口的继承

    2.2 多重继承

    3.内置函数式接口

    3.1 Optional

    3.2 Supplier

    3.3 Consumer例子

    3.4 Predicate操作

    3.5 Function例子

    4.总结


    前面讨论了如何编写 Lambda 表达式, 接下来将详细阐述另一个重要方面: 如何使用Lambda 表达式。 即使不需要编写像 Stream 这样重度使用函数式编程风格的类库, 学会如何使用 Lambda 表达式也是非常重要的。 即使一个最简单的应用,也可能会因为代码即数据的函数式编程风格而受益。

    Java 8中的另一个变化是引入了默认方法和接口的静态方法,它改变了人们认识类库的方式,接口中的方法也可以包含代码体了。

    1.基本类型

    在 Java 中, 有一些相伴的类型, 比如 int 和 Integer——前者是基本类型, 后者是装箱类型。 基本类型内建在语言和运行环境中, 是基本的程序构建模块; 而装箱类型属于普通的 Java 类, 只不过是对基本类型的一种封装。

    Java 的泛型是基于对泛型参数类型的擦除——换句话说, 假设它是 Object 对象的实例——因此只有装箱类型才能作为泛型参数。 这就解释了为什么在 Java 中想要一个包含整型值的列表 List<int>, 实际上得到的却是一个包含整型对象的列表 List<Integer>。麻烦的是, 由于装箱类型是对象, 因此在内存中存在额外开销。 比如, 整型在内存中占用4 字节, 整型对象却要占用 16 字节。

    为了减小这些性能开销,Java 8对整型、长整型和双浮点型做了特殊处理, 因为它们在数值计算中用得最多, 特殊处理后的系统性能提升效果最明显。对基本类型做特殊处理的方法在命名上有明确的规范,如果方法返回类型为基本类型,则在基本类型前加 To,如下图所示:

    如果参数是基本类型,则不加前缀只需类型名即可,如下图所示:

    如果高阶函数使用基本类型,则在操作后加后缀To再加基本类型,如mapToLong。如有可能,应尽可能多地使用对基本类型做过特殊处理的方法,进而改善性能。 这些特殊的 Stream 还提供额外的方法,避免重复实现一些通用的方法,让代码更能体现出数值计算的意图。

     private static void statisticsTest() {
            IntSummaryStatistics summaryStatistics = studentDTOList.stream()
                    .mapToInt(student -> student.getAge()).summaryStatistics();
            System.out.printf("Max:%d,Min:%d,Ave:%f,Sum:%d", summaryStatistics.getMax(), summaryStatistics.getMin(),
                    summaryStatistics.getAverage(), summaryStatistics.getSum());
        }

    这里使用对基本类型进行特殊处理的方法mapToInt,将每个学生映射为学生年龄并转换年龄为int类型。因为该方法返回一个IntStream对象,它包含一个summaryStatistics 方法,这个方法能计算出各种各样的统计值,如 IntStream 对象内所有元素中的最小值、最大值、平均值以及数值总和。

    2.默认方法

    Collection接口中新增加了stream方法,如何能让Collection的子类在不实现该方法的情况下通过编译?Java 8通过在接口中增加默认方法来解决该问题,在任何接口中,无论函数接口还是非函数接口,都可以使用该方法。Iterable接口中也新增加了一个默认方法:forEach,该方法的功能和for循环类似,但是允许用户使用一个Lambda表达式作为循环体。

        default void forEach(Consumer<? super T> action) {
            Objects.requireNonNull(action);
            for (T t : this) {
                action.accept(t);
            }
        }

    它使用一个常规的for循环遍历Iterable对象,然后对每个值调用accept方法。和类不同的是,接口没有成员变量,因此默认方法只能通过调用子类的方法来修改子类本身,避免对子类的实现做出各种假设。

    2.1 接口的继承

    子接口重写了父接口中的默认方法,实现类方法在被调用的时候,调用的是子接口的默认方法。

    定义接口Person:

    public interface Person {
        default void say() {
            System.out.println("I am person!");
        }
    }

    定义子接口Child

    public interface Child extends Person{
        @Override
        default void say() {
            System.out.println("I am Child");
        }
    }

    实现类: 

    public class ChildImpl implements Child {
        public static void main(String[] args) {
            ChildImpl child = new ChildImpl();
            child.say();
        }
    }

    输出:I am Child

    2.2 多重继承

    接口允许多重继承,因此有可能碰到两个接口包含签名相同的默认方法的情况。比如我们将上面定义Child方法修改为:

    public interface Child {
        default void say() {
            System.out.println("I am Child");
        }
    }

    ChildImpl 方法定义如下:

    public class ChildImpl implements Child, Person {
       
    }

    此时,javac并不明确应该继承哪个接口中的方法,因此编译器会报错:

    类 com.martin.learn.java8.domain.ChildImpl从类型 com.martin.learn.java8.domain.Child 和 com.martin.learn.java8.domain.Person 中继承了say() 的不相关默认值

    总结:

    • 类胜于接口:如果在继承链中有方法体或抽象的方法声明,那么就可以忽略接口中定义的方法。
    • 子类胜于父类:如果一个接口继承了另一个接口,且两个接口都定义个一个默认方法,那么子类中定义的方法胜出。

    3.内置函数式接口

    @FunctionalInterface注释会强制 javac 检查一个接口是否符合函数接口的标准。 如果该注释添加给一个枚举类型、类或另一个注释,或者接口包含不止一个抽象方法,javac 就会报错,重构代码时,使用它能很容易发现问题。为了更好地支持函数式编程,所以jdk给我们内置了很多常用的函数式接口,一般都是放在java.util.function包中。

    3.1 Optional

    Optional是为核心类库新设计的一个数据类型,用来替换null值。人们常常使用null值表示值不存在,Optional对象能更好地表达这个概念,使用null代表值不存在的最大问题在于NullPointerException,一旦引用一个存储null值的变量,程序就会立即崩溃。下面我们举例说明Optional对象的API,从而切身体会一下它的使用方法。使用工厂方法of,可以从某个值创建出一个Optional对象,Optional对象相当于值的容器,而该值可以通过get方法提取。

    public class OptionalTest {
        public static void main(String[] args) {
            Optional<String> optional = Optional.of("a");
            Assert.isTrue("a".equals(optional.get()), "值不为a");
        }
    }

    Optional对象也可能为空,因此还有一个对应的工厂方法empty,另外一个工厂方法ofNullable则可将一个空值转换成Optional对象。isPresent方法表示一个Optional对象里是否有值。

    public class OptionalTest {
        public static void main(String[] args) {
            Optional<String> empty = Optional.empty();
            Optional alsoEmpty = Optional.ofNullable(null);
            System.out.println(empty.isPresent());
            System.out.println(alsoEmpty.isPresent());
        }
    }
    

    输出结果如下:

    false
    false

    使用Optional对象的方式之一是在调用get()方法前,先使用isPresent检查Optional对象是否有值。使用orElse方法则更加简洁,当Optional对象为空时,该方法提供一个备选值;也可以使用orElseGet方法,该方法接收一个Supplier对象,只用在Optional对象真正为空时才会调用。

    public class OptionalTest {
        public static void main(String[] args) {
            Optional<String> empty = Optional.empty();
            Optional alsoEmpty = Optional.ofNullable(null);
            System.out.println(empty.orElse("a"));
            System.out.println(alsoEmpty.orElseGet(() -> "b"));
        }
    }
    

    输出结果如下:

    a
    b
    

    3.2 Supplier

    supplier<T>接口的作用是向外提供一个数据,拥有get()方法,用它可以产生或者获取我们需要的数据。lambda如果要使用外部局部变量,局部变量必须是final的。

    import java.util.function.Supplier;
    
    /**
     * @date: 2019/7/16 15:40
     * @description:
     */
    public class SupplierTest {
        private static void method(Supplier<String> supplier) {
            String str = supplier.get();
            System.out.println(str);
        }
    
        public static void main(String[] args) {
            String str = "Hello";
            method(() -> str);
        }
    }

    3.3 Consumer例子

    和Supplier相反,该函数式接口用于消费数据,比如对于获取的数据,做下一步的处理:

    
    import java.util.function.Consumer;
    
    /**
     * @date: 2019/7/16 15:53
     * @description:
     */
    public class ConsumerTest {
        public static void method(Consumer<String> consumer) {
            //接收待处理的数据
            consumer.accept("Hello World");
            consumer.accept("I am pretty");
        }
    
        public static void method2(Consumer<String> one, Consumer<String> two) {
            //分别先执行one操作,然后再做two操作
            one.andThen(two).accept("Hello World");
        }
    
        public static void main(String[] args) {
            //t表示consumer中保存的数据逐一遍历
            method(t -> {
                System.out.println(t.toUpperCase());
            });
    
            method2(one -> System.out.println(one.toLowerCase()), two -> System.out.println(two.toUpperCase()));
        }
    }
    

    输出结果如下:

    HELLO WORLD
    I AM PRETTY
    hello world
    HELLO WORLD

    3.4 Predicate操作

    Predicate接口用于断言,也叫谓语接口,简单的判断“是”与“不是”:接收一个参数,得到一个boolean结果值,多用于判断和过滤。

    import java.util.function.Predicate;
    
    /**
     * @author: martin
     * @date: 2019/7/16 16:37
     * @description:
     */
    public class PredicateTest {
        private static void method(Predicate<String> predicate) {
            boolean longCheck = predicate.test("Hello World");
            if (longCheck) {
                System.out.println("字符串太长");
            } else {
                System.out.println("字符串符合要求");
            }
        }
    
        public static void main(String[] args) {
            method(s -> s.length() > 40);
        }
    }
    
    输出结果为:
    字符串符合要求
    

    3.5 Function例子

    函数式编程中函数是可以作为参数的,该接口的作用即是如此。这样函数就可以被传递与复用,说白了就是一个复合函数:f(g(x),g(x)作为f(y)的参数:

    import java.util.function.Function;
    
    /**
     * @date: 2019/7/16 16:55
     * @description:
     */
    public class FunctionTest {
        /**
         * 转换逻辑
         *
         * @param function
         */
        public static void method(Function<String, Integer> function) {
            Integer apply = function.apply("100");
            System.out.println(apply);
        }
    
        public static void method2(Function<String, String> one, Function<String, Integer> two) {
            //先执行one操作,再执行two操作
            Integer age = one.andThen(two).apply("张三,12");
            age++;
            System.out.println("年龄:" + age);
        }
    
        public static void method3(Function<String, String> one, Function<String, Integer> two) {
            //先执行one操作,再执行two操作
            Integer age = two.compose(one).apply("张三,12");
            age++;
            System.out.println("年龄:" + age);
        }
    
        public static void main(String[] args) {
            method(Integer::parseInt);
            method2(s -> s.split(",")[1],Integer::parseInt);
            method2(s -> s.split(",")[1],Integer::parseInt);
        }
    }
    

    输出结果如下:

    100
    年龄:13
    年龄:13

    4.总结

    • 使用为基本类型定制的Lambda表达式和Stream,如IntStream可以显著提升系统性能
    • 默认方法是指接口中定义的包含方法体的方法,方法名有default关键字做前缀。
    • 在一个值可能为空的情况下,使用Optional对象能替代使用null值。
    展开全文
  • 简单类库

    2020-07-26 23:57:59
    类库就是在库存里提前写好的,import后拿来调用的类 类即有成员变量,构造方法,和成员方法 Object类库 常用方法 equals 指示其他某个对象是 否与此对象“相等” 两种重写 Shift+Alt+S加快捷键生成的 @Override ...

    类库就是在库存里提前写好的,import后拿来调用的类
    类即有成员变量,构造方法,和成员方法

    Object类库

    常用方法

    equals

    指示其他某个对象是 否与此对象“相等”
    两种重写
    Shift+Alt+S加快捷键生成的

    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (age != other.age)
    			return false;
    		if (name == null) {
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}
    

    利用instanceceof判断生成的

    @Override
    	public boolean equals(Object obj) {
    		if(obj instanceof Person) {
    			Person other = (Person)obj;
    			if(this.age == other.age) {
    				return true;
    			}
    		}
    		return false;
    	}
    

    toString

    返回该对象的字符串表示
    直接就是对象打印出来
    不重写就是打印默认字符串:类名@对象的十六进制哈希码(hashCode)

    包装类

    数值包装类(Byte、Short、Integer、Long、Float和Double)
    1这几个每个类都有两个构造方法:
    Integer(int value):通过指定一个数值构造Integer对象。
    Integer(String s):通过指定一个字符串s构造对象,s是十进制字符串表示的数值。???
    2这6个数值包装类有一个共同的父类—— Number,Number是一个抽象类,除了这6个子 类还有:AtomicInteger、AtomicLong、 BigDecimal和BigInteger,其中BigDecimal和 BigInteger后面还会详细介绍。Number是抽象类,要求它的子类必须实现如下6个方法:
    int intValue():将当前包装的对象转换为int 类型的数值.第一个int就是创建出来的对象
    3
    以 Integer为例,方法定义如下:
    static int parseInt(String s):将字符串s转换有 符号的十进制整数。
    static int parseInt(String s, int radix):将字符串s转换有符号的整数,radix是指定基数,基数用来指定进制。注意这种指定基数的方法在浮点数包装类(Double和Float)中没有的

    		//1.构造对象
    		//创建数值为80的Integer对象
    		Integer objInt = new Integer(80);
    		//创建数值为80.0的Double对象
    		Double objDouble = new Double(80.0);
    		
    		//2.Number类方法转值
    		//Number是抽象类,是数值包装类的共同父类;方法都是转值的,格式:xxxValue()
    		//Number类中的方法比如int  public abstract int intValue()
    		//Integer对象转换为long数值
    		long longVar = objInt.longValue();//调用父类里的方法,抽象的
    		//Double对象转换为int数值
    		int intVar = objDouble.intValue();
    		
    		//3.compareTo()方法
    		//对象调用
    		//方法 返回值是int,如果返回值是0,则相等;如果返 回值小于0,则此对象小于参数对象;如果返回 值大于0,则此对象大于参数对象。
    		Float objFloat = new Float(100);
    		Float objFloat1 = new Float(200);
    		int i = objFloat.compareTo(objFloat1);
    		//i = -1;表示objFloat小于objFloat1
    		System.out.println(i);
    		
    		//4.字符串转换为基本类型
    		//数值包装类的类名比如Integer调用转换。Integer.parseInt();
    		int intVar2 = Integer.parseInt("100");
    		//类方法public static int parseInt(String s) 
    		int intVar3 = Integer.parseInt("ABC", 16);
    		//类方法public static int parseInt(String s, int radix) radix是进制
    		
    		//5基本类型转字符串
    		String str1 = Integer.toString(100);
    		String str2 = Integer.toString(100, 16);
    
    	}
    
    

    Character

    Character(char value):构造方法,通过char值创 建一个新的Character对象

    
    		// 创建数值为'A'的Character对象
    		Character objChar1 = new Character('A');
    		// 从Character对象返回char值 
    		char ch = objChar1.charValue(); 
    		// 字符比较 
    		Character objChar2 = new Character('C');
    		int result = objChar1.compareTo(objChar2); 
    		// result = -2,表示objChar1小于objChar2 
    		if (result < 0) {
    			System.out.println("objChar1小于objChar2"); 
    			}
    

    Boolean类

    Boolean类有两个构造方法
    Boolean(boolean value):通过一个boolean值创建Boolean对象。
    //Boolean(String s):通过字符串创建Boolean对象。s不能为null,s如果是忽略大小写"true"则转换为true对象,其他字符串都转 换为false对象。

    Boolean类有int compareTo(Boolean包装类对象) 方法,可以进行包装对象的比较。方法返回值 是int,如果返回值是0,则相等;如果返回值小 于0,则此对象小于参数对象;如果返回值大于 0,则此对象大于参数对象

    s不能为null,s如果是 忽略大小写"true"则转换为true,其他字符串都 转换为false。

    		// 创建数值为true的Character对象true 
    		Boolean obj1 = new Boolean(true);
    		// 通过字符串"true"创建Character对象true 
    		Boolean obj2 = new Boolean("true"); 
    		// 通过字符串"True"创建Character对象true 
    		Boolean obj3 = new Boolean("True"); 
    		// 通过字符串"TRUE"创建Character对象true 
    		Boolean obj4 = new Boolean("TRUE"); 
    		// 通过字符串"false"创建Character对象false 
    		Boolean obj5 = new Boolean("false"); 
    		// 通过字符串"Yes"创建Character对象false 
    		Boolean obj6 = new Boolean("Yes"); 
    		// 通过字符串"abc"创建Character对象false 
    		Boolean obj7 = new Boolean("abc"); 
    		boolean b1 = Boolean.parseBoolean("true"); 
    		boolean b2 = Boolean.parseBoolean("True"); 
    		boolean b3 = Boolean.parseBoolean("TRUE");
    
    展开全文
  • Java常用类库

    2018-11-22 00:24:45
    1):StringBuffer类: String、StringBuffer、StringBuilder的区别 1.String一旦声明,不可改变,StringBuffer与StringBuilder声明的内容可以改变 2.StringBuffer类中提供的方法都是同步方法,属于安全的线程...

    1):StringBuffer类:

    String、StringBuffer、StringBuilder的区别

    1.String一旦声明,不可改变,StringBuffer与StringBuilder声明的内容可以改变

    2.StringBuffer类中提供的方法都是同步方法,属于安全的线程操作,而StringBuilder类中大的方法都是属于异步方法,属于非线程安全的操作。

    2):Runtime类

    Runtime类是Java中与运行时环境有关的操作类,利用此类可以取得系统的内存信息,也可以利用此类产生新的操作系统进程对象。

    Runtime类表示运行时操作类,是一个封装了JVM进程的类,每一个JVM都对应着一个Runtime类的实例,此实例由JVM运行时为其实例化。

    Runtime run = Runtime.getRuntime();

    package library;
    
    public class RuntimeDemo {
    	public static void main(String[] args) {
    		Runtime run = Runtime.getRuntime();//通过Runtime类的静态方法为其进行实例化操作
    		System.out.println("JVM最大内存量:"+run.maxMemory());//观察最大内存量,根据机器环境会有所不同
    		System.out.println("JVM空闲内存量:"+run.freeMemory());//取得程序运行时的内存空闲量
    		String str = "Hello"+"World"+"!!!"+"\t"+"Welcome"+"To"+"MLDN"+"~";
    		System.out.println(str);
    		for (int i = 0; i < 100; i++) {//循环修改Sting,产生多个垃圾,会占用内存
    			str+=i;
    		}
    		System.out.println("操作String之后的,JVM空闲内存量:"+run.freeMemory());//观察有多个垃圾空间产生之后的内存空闲量
    		run.gc();//进行垃圾收集,释放空间
    		System.out.println("垃圾回收之后的,JVM空闲内存量:"+run.freeMemory());//垃圾收集之后的内存空闲量。
    	}
    }
    

    结果:

    JVM最大内存量:66650112
    JVM空闲内存量:4934616
    HelloWorld!!!	WelcomeToMLDN~
    操作String之后的,JVM空闲内存量:4877968
    垃圾回收之后的,JVM空闲内存量:5015840

    1.GC(Garbage Collector,垃圾收集器)指的是释放无用的内存空间。

    2.GC会由系统不定期进行自动回收,或者调用Runtime类中的gc()方法手工回收。

    Runtime类与Process类

    调用本机可执行程序

    package library;
    
    import java.io.IOException;
    
    /**
     * 调用本机可以执行程序
     * 让记事本进程5s后消失
     */
    public class RuntimeDemo2 {
    	public static void main(String[] args) {
    		Runtime run = Runtime.getRuntime();//通过Runtime类的静态方法为其进行实例化操作
    		Process pro = null;//声明一个Process对象,接受启动的进程
    		try {
    			pro = run.exec("notepad.exe");//调用本机程序,必须进行异常处理
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();//打印异常信息
    		}
    		try {
    			Thread.sleep(5000);//让此线程存活5s
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();//打印异常信息
    		}
    		pro.destroy();//结束此进程
    	}
    }
    

    3):国际化程序

    国际化操作是指程序可以同时适应多门语言。

    实现国际化光靠Locale类是不够的,还需要属性文件和ResourceBundle类的支持。属性文件是指扩展名为.properties的文件,文件中的内容保存结构是一种“key=value”的形式,因为国际化的程序只显示语言的不同,那么就可以根据不同的国家定义不同的属性文件,属性文件中保存真正要使用的文字信息,要访问这些属性文件,可以使用ResourceBundle类来完成。

    实现java程序国际化操作必须通过一下3各类完成:

    java.util.Local-----java.util.ResourceBundle---MessageFormat

    通过Locale类所指定的区域码,然后ResourceBundle根据Locale类所指定的区域码找到相应的资源文件,如果资源文件(属性文件)中存在动态文本,子使用MesssageFormat进行格式化。

    属性文件定义时,必须要按照“名称_国家代码”的形式命名,即所有的相关属性文件的名称全部一样,只有国家的代码不一样,代码如下

    (处理动态文本:以中文为例是:”你好,xxx!“,其中“xxx”的内容是由程序动态设置的,那么就需要使用占位符清楚地表示出动态文本的位置,占位符使用“{编号}”的格式出现。使用占位符之后,程序可以使用MessageFormat对信息进行格式化。为占位符动态设置文本的内容。)

    1.中文的属性代码文件:Message_zh_CN.propertiesinfo = \u4f60\u597d\uff01

    以上信息就是中文:你好,{0}!

    2.英语属性文件:Message_en_US.properties

    info = Hello,{0}!

    3.法语属性文件:Message_fr_FR.properties

    info = Bonjour,{0}!

    通过Locale类和ResourceBundle类读取属性文件的内容,代码如下:

    package library;
    
    import java.text.MessageFormat;
    import java.util.Locale;
    import java.util.ResourceBundle;
    
    public class InterDemo {
    	public static void main(String[] args) {
    		Locale zhLoc = new Locale("zh","CN");//表示中国地区
    		Locale enLoc = new Locale("en","US");
    		Locale frLoc = new Locale("fr","FR");
    		ResourceBundle zhrb = ResourceBundle.getBundle("Message",zhLoc);//找到中文的属性文件(.getBundle(文件名称,区域码))
    		ResourceBundle enrb = ResourceBundle.getBundle("Message",enLoc);
    		ResourceBundle frrb = ResourceBundle.getBundle("Message",frLoc);
    		String str1 = zhrb.getString("info");
    		String str2 = enrb.getString("info");
    		String str3 = frrb.getString("info");
    		System.out.println("中文:"+MessageFormat.format(str1, "你好"));//通过键值读取属性文件的类容
    		System.out.println("英文:"+MessageFormat.format(str2, "nihao"));
    		System.out.println("法文:"+MessageFormat.format(str3, "nihao"));
    		
    	}
    }
    

    结果:

    中文:你好,你好!
    英文:Hello,Hello!
    法文:Bonjour,Hello!

    多个占位符设置多个动态文本:

    MessageFormat.format(str1,"你好",“hello”,"hello")

    info = Hello,{0},{1},{2}!

     

    4):System类、

    System类是一些与系统相关的属性和方法的集合,而且在System类中所有的书信给都是静态的,要引用这些属性和方法,直接使用System类调用即可。

    System.gc():垃圾对象的回收,如果在一个对象被回收之前要进行某些操作,那么该怎么办呢,实际上,在Object类中有一个finalize()方法,此方法定义如下:

    protected  void finalize() throws Throwable

    package library.finalize;
    
    public class Person {
    	private String name; 
    	private int age ;
    	
    	public Person(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "年龄:age=" + age + ",姓名: name=" + name ;
    	}
    	public void finalize()throws Throwable{//对象释放空间时默认调用此方法
    		System.out.println("对象被释放 -->"+this);//直接打印对象调用toString
    	}
    	
    	public static void main(String[] args) {
    		Person per = new Person("张三",30);
    		per = null;//断开引用释放空间
    		//以上代码不会在显示器显示输出
    		System.gc();//强制性释放空间,,会调用fianlize()方法
    	}
    	
    }
    

    结果:

    对象被释放 -->年龄:age=30,姓名: name=张三

    5):日期操作类

    Date类:实例化对象  Date date = new Date();------输出当前日期

    Calendar类,可以将取得的时间精确到毫秒,但是他是一个抽象类,依靠其子类GregorianCalendar类。

    Dateformat类

    SimpleDateFormat类

    6)Math类

    7):Random类

    8):NumberFormat类

    9):BigInteger类

    10):Bigdecimal类

    11):对象克隆技术

    12):Arrays类

    package library;
    
    import java.util.Arrays;
    
    public class ArraysDemo {
    	public static void main(String[] args) {
    		int temp[] = {3,5,7,9,1,2,6,8};
    		Arrays.sort(temp);	//数组排序
    		System.out.println("排序后数组:");
    		System.out.println(Arrays.toString(temp));//以字符串输出数组
    		int point = Arrays.binarySearch(temp, 3);//检索数据位置
    		System.out.println("元素3的位置在:"+point);
    		Arrays.fill(temp, 3);					//填充数组
    		System.out.println("数组填充:");
    		System.out.println(Arrays.toString(temp));//一字符串输出数组
    	}
    }
    

    结果:

    排序后数组:
    [1, 2, 3, 5, 6, 7, 8, 9]
    元素3的位置在:2
    数组填充:
    [3, 3, 3, 3, 3, 3, 3, 3]
    

    13):Comparable接口

    比较器主要是针对对象数组的操作

    package library.comparabledemo;
    
    import java.util.Arrays;
    
    public class Student implements Comparable<Student> {
    
    	private String name;
    	private int age;
    	private float score;
    	
    	public Student(String name, int age, float score) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.score = score;
    	}
    
    	@Override
    	public String toString() {
    		return "Student [age=" + age + ", name=" + name + ", score=" + score
    				+ "]";
    	}
    
    	@Override
    	public int compareTo(Student o) {
    		if (this.score>o.score) {
    			return -1;
    		}else if (this.score<o.score) {
    			return 1;
    		} else {
    			if (this.age>o.age) {
    				return 1;
    			}else if (this.age<o.age) {
    				return -1;
    			}else {
    				return 0;
    			}
    		}
    	}
    	public static void main(String[] args) {
    		Student stu[] = {new Student("张三",20,90.0f),new Student("王五", 20, 99.0f),
    				new Student("孙七", 22, 100.0f),new Student("李四", 22, 9.0f),
    				new Student("赵六", 20, 70.0f),};
    		Arrays.sort(stu);
    		for (int i = 0; i < stu.length; i++) {
    			System.out.println(stu[i]);
    		}
    	}
    }
    

    结果:

    Student [age=22, name=孙七, score=100.0]
    Student [age=20, name=王五, score=99.0]
    Student [age=20, name=张三, score=90.0]
    Student [age=20, name=赵六, score=70.0]
    Student [age=22, name=李四, score=9.0]
    

    分析比较器的排序原理

    使用的是二叉树排序方法,即通过二叉树进行排序,然后利用中序遍历的方式把内容依次读取出来。

    二叉树排序的基本原理就是:将第1个内容作为根节点保持,如果后面的值比根节点的值小,则放在根节点的左子树,如果后面的值比根节点的值大,则放在根节点的右子树。

    找这样的思路,如果给出了一下数字:8、3、10、14、6、4、7、1、13

    在根据中序遍历的原理(左子树---根节点---右子树的方式),排序后的结果:1、3、4、6、7、8、10、13、14

    package library.comparabledemo;
    
    public class BinaryTree {
    	class Node{											//申明一个节点类
    		private Comparable data;						//保存具体类容
    		private Node left;								//保存左子树
    		private Node right;								//保存右子树
    		
    		public void addNode(Node newNode){
    			if(newNode.data.compareTo(this.data)<0){
    				if(this.left==null){					//放在左子树
    					this.left = newNode;
    				}else {
    					this.left.addNode(newNode);			//递归
    				}
    			}
    			if(newNode.data.compareTo(this.data)>=0){
    				if (this.right==null) {					//放在右子树
    					this.right = newNode;
    				}else {
    					this.right.addNode(newNode);		//递归
    				}
    			}
    		}
    		
    		public void printNode(){						//输出时采用中序遍历
    			if(this.left!=null){						//如果左子树有值,则递归调用该方法,该操作会将中序,root.data左边的数字现输出,而且时从小到大的顺序
    				this.left.printNode();
    			}
    			System.out.print(this.data+"\t");			//输出root.data--->根节点
    			if (this.right!=null) {						//如果右子树有值,则递归调用该方法,该操作会将中序,root.data左边的数字现输出,而且时从小到大的顺序
    				this.right.printNode();
    			}
    		}
    	}
    	
    	private Node root;									//根元素
    	
    	public void add(Comparable data){
    		Node newNode = new Node();						//每传入一个数值,就声明一个新的根节点
    		newNode.data = data;
    		if (root == null) {
    			root = newNode;								//如果是第1个元素,设置根节点
    		}else {
    			root.addNode(newNode);						//确定结点是放在左子树还是右子树
    		}
    	}
    	
    	public void print(){								//输出节点
    		this.root.printNode();
    	}
    	
    	public static void main(String[] args) {
    		BinaryTree bt = new BinaryTree();
    		bt.add(8);
    		bt.add(7);
    		bt.add(14);
    		bt.add(10);
    		bt.add(4);
    		bt.add(1);
    		bt.add(13);
    		bt.add(6);
    		bt.add(3);
    		System.out.println("排序后的结果:");
    		bt.print();
    	}
    }
    

    结果:

    排序后的结果:
    1	3	4	6	7	8	10	13	14	

    15):Observable类和Observer接口,

    他们可实现观察者模式(详情请移步:https://blog.csdn.net/weixin_42476601/article/details/84262436

    16):正则表达式

    常用正则规则
    序号 规范 描述 序号 规范 描述
    1 \\ 表示反斜线(\)字符 9 \w 字母、数字、下划线
    2 \t 制表符 10 \W 非字母、数字、下划线
    3 \n 换行 11 \s 所有的空白字符(如:换行,空格等)
    4 [abc] 字符a、b 或c 12 \S 所有非空白字符
    5 [^abc] 除了abc以外的任意字符 13 ^ 行的开头
    6 [a-zA-Z0-9] 由字母、数字组成 14 $ 行的结尾
    7 \d 数字 15 . 匹配除换行符之外的任意字符
    8 \D 非数字      
    数量表示(X表示一组规范)
    序号 规范 描述 序号 规范 描述
    1 X 必须出现依次 5 X{n} 必须出现n次
    2 X? 出现0或1次 6 X{n,} 必须出现n次以上
    3 X* 出现0、1次或多次 7 X{n,m} 必须出现n~m次
    4 X+ 可以出现1次或多次      
    逻辑运算符(X、Y表示一组规范)
    序号 规范 描述 序号 规范 描述
    1 XY X规范后跟着Y规范 5 (X) 作为一个捕获组规范
    2 X|Y X规范或Y规范      
    package library.regex;
    
    public class RegexDemo1 {
    
    	public static void main(String[] args) {
    		String info = "LXH:98|MLDN:90|LI:100";
    		String s[] = info.split("|");			//按照“|”拆分
    		System.out.println("字符串的拆分:");
    		for (int i = 0; i < s.length; i++) {
    			System.out.print(s[i]+"、");
    		}
    	}
    }
    
    结果:
    字符串的拆分:
    、L、X、H、:、9、8、|、M、L、D、N、:、9、0、|、L、I、:、1、0、0、
    package library.regex;
    
    public class RegexDemo2 {
    	public static void main(String[] args) {
    		String info = "LXH:98|MLDN:90|LI:100";
    		String s[] = info.split("\\|");			//按照“|”拆分,需要转义
    		System.out.println("字符串的拆分:");
    		for (int i = 0; i < s.length; i++) {
    			String s2[] = s[i].split(":");
    			System.out.println("\t|--"+s2[0]+"\t"+s2[1]);
    		}
    	}
    }
    
    字符串的拆分:
    	|--LXH	98
    	|--MLDN	90
    	|--LI	100
    

    17):定时调度---Timer类、TimerTask类

    Timer类是一个线程设施,可以用来实现在某一个时间或某一段时间后按排某一个任务执行一次或定期重复执行。该功能要与TimerTask配合使用。

    package library.timer;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.TimerTask;
    
    public class MyTask extends TimerTask {			//任务调度类要继承TimmerTask类
    	
    	@Override
    	public void run() {
    		// TODO Auto-generated method stub
    		SimpleDateFormat sdf = null;
    		sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSSS");
    		System.out.println("当前系统时间:"+sdf.format(new Date()));
    	}
    
    }
    
    package library.timer;
    
    import java.util.Timer;
    
    public class TestTask {
    	public static void main(String[] args) {
    		Timer t = new Timer();				//建立Timer对象
    		MyTask mt = new MyTask();			//定义任务
    		t.schedule(mt, 1000,2000);			//设置任务的执行,1秒后开始,每2秒重复
    	}
    }
    
    
    部分结果:
    当前系统时间:2018-11-22 00:09:27:0842
    当前系统时间:2018-11-22 00:09:29:0816
    当前系统时间:2018-11-22 00:09:31:0826
    当前系统时间:2018-11-22 00:09:33:0840
    

    要点:

    1. 字符串频繁修改使用StringBuffer类,线程安全
    2. Runtime表示运行时,在JVM中只有一个Runtime,所以想取得Runtime类的对象,直接使用Runtime类中提供的静态方法getRuntime()即可
    3. 国际化程序实现的基本原理:所有的语言信息已key-->value的形式保存在资源文件中,程序通过key找到相应的value,根据其所设置国家的Locale对象不同,找到的资源文件也不同,要想实现国际化必须依靠Locale、ResourceBundle两类共同完成
    4. System是系统类,可以取得系统的相关信息,使用System.gc()方法可以强制性进行垃圾回收操作,调用此方法实际上就是调用Runtime类中的gc()方法
    5. Format类为格式操作类,主要的3个子类是Messageformat、NumberFormat、DateFormat。
    6. 使用Date类可以方便的取得时间,但取得时间格式不符合低于的习惯,所有可以使用SimpleDateFormat类进行日期的格式化操作
    7. 处理大数字可以使用BigInteger、BigDecimal,当需要精确小数点操作位数时,使用Bigdecimal类即可
    8. 通过Random类可以取得指定范围的随机数字
    9. 如果一个类的对象要箱被克隆,则此对象所在的类必须实现Cloneable接口
    10. 要箱对一组对象进行排序,则必须使用比较器。比较器接口Comparable中定义了一个compareTo()的比较方法,用来设置比较规则。
    11. 正则表达式是在开发中最常使用的一种验证方法,String类中的replaceAll()、split()、matches()方法都是对正则有所支持
    12. 可以使用Timer类和TimerTask类完成系统的定时操作。
    展开全文
  • 遵循我们上面的命名空间定义规范的话,基本上可以完成类库的自动加载了,但是如果定义了较多的命名空间的话,效率会有所下降,所以,我们可以给常用的类库定义类库映射。命名类库映射相当于给类文件定义了一个别名,...
  • 1、C++调用C#类库 1.准备C#类库(dll文件) 1.1.创建C#类库: 右击项目类库生成即可, 出现.dll(类库)与.pdb(pdb文件包含了编译后程序指向源代码的位置信息, 用于调试的时候定位到源代码,主要是用来方便调试...
  • C#类库查询手册

    2020-07-30 23:32:36
    C#类库查询手册 PDF格式,带目录,800页,很全。
  • 文件——新建——项目,点选Windows经典桌面——类库,在下面的解决方案里有{创建新解决方案、添加到解决方案、在新实例中创建},如果想在已创建的项目文件中使用该类库,那么就选择添加到解决方案,这样你在你的...
  • C#类库的封装和引用

    2019-06-28 08:15:42
    C#类库的封装和引用 开发工具与关键技术: VS C# 作者:李寿宇 撰写时间:2019/6/25 在学习期间和做项目等的时候如果遇到一些方法多次用时或者同一对象,这时建一个类库(.NET Framework)新建类库的时候项目名称要...
  • TP5 中引入第三方类库

    2017-10-21 17:53:50
    通过了解tp5的目录结构,我们知道其中有两个目录是纺织扩展类库文件的。 extend是放置自定义或者其他类文件的。 vendor目录是放置composer类库文件的。 当我们的第三方类库文件是下载的,而且类文件目录一层又一层,...
  • Java中如何使封装自己的类,建立并使用自己的类库?  ——感谢您的阅读,转载请标明出处! 随着自己的编程经历的积累会发现往往自己在一些项目中写的类在别的项目中也会有多次用到。你肯定会想:如何自己的写的一些...
  • 通过使用标准类库,可以充分利用这些编写标准类库的专家的知识,以及在你之前的其他人的使用经验。 使用标准类库的第二个好处是,不必浪费时间为那些与工作不太相关的问题提供特别的解决方案。就像大多数程序员...
  • Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64,所以每6个比特为一个单元,对应某个可打印字符。... ,这样共有62个字符,此外两个可打印符号在不同的系统中而不同(本类库里面用的
  • VC如何调试类库

    2019-07-05 05:23:16
    一个解决方案下面,有个静态类库的项目和一个MFC项目,MFC应用了类库项目编译生成的.lib文件,但是要是给类库项目的源文件里面打上断点的话,MFC项目是无法进入断点的。那么就要右键MFC项目,点击“引用”,在引用...
  • 004 .NET Framework类库

    2020-05-12 22:30:10
    在.NET Framework架构中,在CLR的上层为.NET Framework的类库。.NET提供的强大的类库可以帮助开发人员轻松地构建应用程序。.NET中的类库封装了对Wmdows、网络、文件及多媒体的处理功能,是所有NET语言都必须使用的...
  • Java常用类库和API

    2020-05-14 17:39:35
    如果不会总结,很多知识学习后想回顾就会花很多时间,这里总结一下Java常用的类库,都是日常开发中常用到的库,并且之后用到比较好用的库也会再这里添加 日志类库 无论是开发,学习和运维,日志已经是每个环节都必须...
  • Thinkphp 扩展/类库扩展

    2018-07-22 10:39:01
    类库扩展 ThinkPHP的类库主要包括公共类库和应用类库,都是基于命名空间进行定义和扩展的。只要按照规范定义,都可以实现自动加载。   公共类库 公共类库通常是指ThinkPHP/Library目录下面的类库,例如: ...
1 2 3 4 5 ... 20
收藏数 420,059
精华内容 168,023
关键字:

类库