Java核心类库上

[toc]

1.常用类的概述和使用

1.1 常用的包

• java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入。

  • 如：System类、String类、…
• java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等。 如：Scanner类、Random类、List集合、…
• java.io包 - 该包是Java语言中的输入输出包，里面提供了大量读写文件相关的类等。 如：FileInputStream类、FileOutputStream类、…
• java.net包 - 该包是Java语言中的网络包，里面提供了大量网络编程相关的类等。 如：ServerSocket类、Socket类、…
• java.sql 包 - 该包是Java语言中的数据包，里面提供了大量操作数据库的类和接口等。 如：DriverManager类、Connection接口、…
• … …
• Java程序员在编程时可以使用大量类库，因此Java编程时需要记的很多，对编程能力本身要求不是 特别的高。

1.2 Object类

基本概念

• java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间接子类

• 如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类。

• Object类定义了“对象”的基本行为, 被子类默认继承。

常用方法

question：notify()可以唤醒等待的单个线程，那如果有两个线程在等待，它会唤醒哪一个呢，是否可以指定呢

1.3 包装类

    通常情况下，基本数据类型的变量不是对象，为了满足万物皆对象的理念，需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。

1.3.1 包装类的分类

1.3.2 Integer类

    java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。

常用方法

装箱与拆箱的概念

    在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。  从Java5开始增加了自动拆箱和自动装箱的功能。

自动装箱池

    在Integer类的内部提供了自动装箱池技术，将 -128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。

• 使用自动装箱池中的数值，数值相同时，地址相同

• 使用手动装箱，数值相同时，地址不同

// 装箱，相当于从int类型转换为Integer类型
Integer it1 = Integer.valueOf(123);
// 从String类型到Integer类型
Integer it2 = Integer.valueOf("123");
// 拆箱，获取调用对象的整数数值
int ia = it2.intValue();
// 自动装箱与拆箱
Integer it3 = 100;//直接通过赋值装箱
int ib = it3;      //直接通过赋值拆箱
// 将字符串转为int
int ic = Integer.parseInt("200")

1.3.3 Character类

    java.lang.Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型的包装并提供字符类别的判断和转换等方法

常用方法

1.3.4 使用总结

• 基本数据类型转换为对应包装类的方式

  • 调用包装类的构造方法或静态方法valueOf即可

• 获取包装类对象中基本数据类型变量数值的方式

  • 调用包装类中的xxxValue方法即可

• 字符串转换为基本数据类型的方式

  • 调用包装类中的parseXxx方法即可

1.4 数学处理类

1.4.1 Math类

java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。

常用方法

1.4.2 BigDecimal类

    由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型加以描述。

1.4.3 BigInteger类

    若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述

常用方法

2. String类的概述和使用

2.1 String类的概念

• java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如：”abc”。

• 该类由final关键字修饰，表示该类不能被继承。

• 从jdk1.9开始该类的底层不使用char[]来存储数据，而是改成byte[]加上编码标记，从而节约了一 些空间。

• 该类描述的字符串内容是个常量不可更改，因此可以被共享使用。

  String str1 = "abc";// "abc"这个字符串是个常量不可改变
  str1 = "123";        
  // 将"123"这个字符串的地址赋值给变量str1，
  // 改变了str1的指向，并没有改变“abc”这个字符串
  

2.2 常量池

    由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象，从而提高了性能。

2.3 常用的构造方法

// 请问下面的代码会创建几个对象？分别存放在什么地方？
String str1 = "hello";  // 1个对象，常量池中
String str2 = "world";  // 2个对象，1个在常量池，1个在堆区
// 常量池与堆区对象的比较
String str1 = "hello";  // 常量池
String str2 = "hello";  // 常量池
String str3 = new String("hello"); // 堆区
String str4 = new String("hello"); // 堆区
System.out.println(str1 == str2);       // 比较地址  true
System.out.println(str1.equals(str2));  // 比较内容  true
System.out.println(str3 == str4);       // 比较地址  false
System.out.println(str3.equals(str4));  // 比较内容  true
System.out.println(str2 == str4);       // 比较地址  false
System.out.println(str2.equals(str4));  // 比较内容 true
// 常量优化机制，变量没有
String str5 = "abcd";
String str6 = "ab" + "cd";  // 常量优化机制  "abcd"
System.out.println(str5 == str6); // 比较地址  true

String str7 = "ab";
String str8 = str7 + "cd"; // 没有常量优化
System.out.println(str5 == str8); // 比较地址 false，str8在哪里呢，堆区吗？

2.4 常用的成员方法

2.5 正则表达式

    正则表达式本质就是一个“规则字符串”，可以用于对字符串数据的格式进行验证，以及匹配、查找、替换等操作。该字符串通常使用^运算符作为开头标志，使用$运算符作为结尾标志，当然也可以省略。

正则表达式的规则

3. 可变字符串类和日期相关类

3.1 可变字符串类

3.1.1 基本概念

• 由于String类描述的字符串内容是个常量不可改变，当需要在Java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费。
• 为了解决上述问题，可以使用java.lang.StringBuilder类和java.lang.StringBuffer类来描述字符序列可以改变的字符串，如：”ab”。
• StringBuffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低，许多方法都用synchronized关键字修饰
• StringBuilder类是从jdk1.5开始存在，属于非线程安全的类，效率比较高

3.1.2 StringBuilder类

常用构造方法

常用方法

• 注意：作为参数传递时，方法内部String不会改变其值，StringBuffer和StringBuilder会改变其值

String str1 = new String("hello");
String str2 = str1.toUpperCase();
System.out.println("str2 = " + str2); // HELLO
System.out.println("str1 = " + str1); // hello  字符串本身是个常量不会改变

StringBuilder sb4 = sb3.insert(0, "abcd");
System.out.println("sb4 = " + sb4); // abcdhello  
System.out.println("sb3 = " + sb3); // abcdhello
// 返回调用对象自己的引用，也就是返回值和调用对象是同一个字符串

• StringBuilder的很多方法的返回值均为StringBuilder类型。这些方法的返回语句均为：return this。
• 由此可见，这些方法在对StringBuilder所封装的字符序列进行改变后又返回了该对象的引用。基 于这样设计的目的在于可以连续调用。

3.2 Java8之前的日期相关类

3.2.1 System类

java.lang.System类中提供了一些有用的类字段和方法

3.2.2 Date类

java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒

3.2.3 SimpleDateFormat类

java.text.SimpleDateFormat类主要用于实现日期和文本之间的转换

Date d1 = new Date();
System.out.println("d1 = " + d1); // d1 = Sat Jul 25 11:12:16 CST 2020

long millis = System.currentTimeMillis();
Date d2 = new Date(millis);  
System.out.println("d2 = " + d2);  // d2 = Sat Jul 25 11:12:16 CST 2020

SimpleDateFormat slf = new SimpleDateFormat();
String format = slf.format(d1);
System.out.println(format); // 2020/7/25 上午11:15

SimpleDateFormat slf2 = new SimpleDateFormat("yyyy-M-d HH:mm:ss");
String format1 = slf2.format(d1);
System.out.println(format1); // 2020-7-25 11:15:56

// 文本格式必须和定义的slf格式相同，不然无法解析
Date parse = slf.parse("2020/7/25 上午11:12"); 
System.out.println(parse); // Sat Jul 25 11:12:00 CST 2020

3.2.4 Calendar类

• java.util.Calender类主要用于描述特定的瞬间，取代Date类中的过时方法实现全球化。
• 该类是个抽象类，因此不能实例化对象，其具体子类针对不同国家的日历系统，其中应用广泛的是GregorianCalendar（格里高利历），对应世界上绝大多数国家/地区使用的标准日历系统。 | 方法声明 | 功能介绍 | | —- | —- | | static Calendar getInstance() | 获取Calendar类型的引用，其实返回的是一个子类对象，多态使用方式之三 | | void set(int year, int month, int date, int hourOfDay, int minute, int second) | 用于设置年月日时分秒信息, 月份减1 | | Date getTime() | 用于将Calendar类型转换为Date类型 | | void set(int field, int value) | 设定指定字段的数值 | | void add(int field, int amount) | 向指定字段增加数值 |

Calendar instance = Calendar.getInstance();
instance.set(Calendar.YEAR, 2020);  // 设置年份为2020年
instance.add(Calendar.MONTH, 2);  // 月份增加2个月

3.3 Java8中的日期相关类

3.3.1 Java8日期相关类的由来

• JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。

• 而Calendar并不比Date好多少。它们面临的问题是：

  • Date类中的年份是从1900开始的，而月份都从0开始。
  • 格式化只对Date类有用，对Calendar类则不能使用。
  • 非线程安全等。

• Java 8通过发布新的Date-Time API来进一步加强对日期与时间的处理。

  • java.time包：该包日期/时间API的基础包。
  • java.time.chrono包：该包提供对不同日历系统的访问。
  • java.time.format包：该包能够格式化和解析日期时间对象。
  • java.time.temporal包：该包包含底层框架和扩展特性。
  • java.time.zone包：该包支持不同时区以及相关规则的类。

3.3.2 LocalDate类

java.time.LocalDate类主要用于描述年-月-日格式的日期信息，该类不表示时间和时区信息。

3.3.4 LocalTime类

java.time.LocalTime 类主要用于描述时间信息，可以描述时分秒以及纳秒。

3.3.5 LocalDateTime类

描述日期加时间

3.3.6 instant类

java.time.Instant类主要用于描述瞬间的时间点信息。

Instant now = Instant.now();
System.out.println(now);  // 2020-07-25T04:19:53.873876300Z 本初子午线时间

OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);// 2020-07-25T12:19:53.873876300+08:00，东8区时间

3.3.7 DateTimeFormatter类

java.time.format.DateTimeFormatter类主要用于格式化和解析日期。

4.集合

4.1 集合的概述

4.1.1 集合的由来

• 当需要在Java程序中记录单个数据内容时，则声明一个变量。
• 当需要在Java程序中记录多个类型相同的数据内容时，声明一个一维数组。
• 当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。
• 当需要在Java程序中记录多个类型相同的对象数据时，创建一个对象数组。
• 当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合。

4.1.2 集合的框架结构

• Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合。

• 其中Collection集合中存取元素的基本单位是：单个元素。

• 其中Map集合中存取元素的基本单位是：单对元素。

4.2 Collection集合

java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口，因此该接口里定义的方法既可用于操作List集合，也可用于操作Queue集合和Set集合。

常用方法

contains的工作原理就是拿着参数对象与集合中已有的元素依次进行比较，比较的方式调用Objects中的equals方法

4.3 Iterator接口

• java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素。

• java.util.Collection接口继承Iterator接口，因此所有实现Collection接口的实现类都可以使用该迭代器对象。

常用方法

// 使用迭代器模拟toString方法的打印
StringBuilder sb1 = new StringBuilder();
sb1.append("[");
while (iterator1.hasNext()) {
    Object obj = iterator1.next();
    // 当获取的元素是最后一个元素时，则拼接元素加中括号
    if (!iterator1.hasNext()) {
        sb1.append(obj).append("]");
    } else {
        // 否则拼接元素加逗号加空格
        sb1.append(obj).append(",").append(" ");
    }
}
// [one, 2, Person{name='zhangfei', age=30}]
System.out.println("c1 = " + sb1);

4.4 for each循环

• Java5推出了增强型for循环语句，可以应用数组和集合的遍历。

• 是经典迭代的“简化版”。

语法格式

for(元素类型 变量名：数组/集合名称) {
    循环体;
}

执行流程

不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止

4.5 List集合

4.5.1 基本概念

• java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。
• 该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。
• 其中ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。
• 其中LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删元素方便。
• 可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList 更适合于访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。
• 其中Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LIFO)。
• 其中Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的 类，效率比较低，以后开发中基本不用。

4.5.2 常用方法

4.6 Queue集合

• java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。
• 该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO)。
• 该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。

方法

4.7 泛型

4.7.1 基本概念

• 通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。
• 为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型> 的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错。
• 泛型只在编译时期有效，在运行时期不区分是什么类型。

4.7.2 底层原理

• 泛型的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，用于给形式参数E进行初始化，从而使得集合中所有的E被实际参数替换，由于实际参数可以传递各种各样广泛的数据类型，因此得名为泛型。

4.7.3 自定义泛型接口

• 泛型接口和普通接口的区别就是后面添加了类型参数列表，可以有多个类型参数，如： 等。

4.7.4 自定义泛型类

• 泛型类和普通类的区别就是类名后面添加了类型参数列表，可以有多个类型参数，如： 等。

• 实例化泛型类时应该指定具体的数据类型，并且是引用数据类型而不是基本数据类型。

• 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。

• 子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。

  public class Person<T> {}
  // 子类不保留不指定，此时父类中的T默认为Object
  public class SubPerson extends Person {}  
  // 子类不保留泛型但指定父类中的泛型，此时父类中的T被指定为String类型
  public class SubPerson extends Person<String> {}  
  // 保留父类的泛型，可以在构造对象时来指定T的类型
  public class SubPerson<T> extends Person<T> {}
  // 保留父类的泛型，同时在子类中增加新的泛型
  public class SubPerson<T,T1> extends Person<T> {}
  

• String是Object的子类，但是List并不是List

4.7.5 自定义泛型方法

• 泛型方法就是调用时需要输入参数指定泛型的方法

• 格式

  • [访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) {方法体；}
• 在静态方法中使用泛型参数时，需要把静态方法定义为泛型方法。

public static <T1> void printArray(T1[] arr) {
    for(T1 tt: arr) {
        System.out.println("tt = " + tt);
    }
}

4.7.6 通配符的使用

• 有时候我们希望传入的类型在一个指定的范围内，此时就可以使用泛型通配符了
• 如：之前传入的类型要求为Integer类型，但是后来业务需要Integer的父类Number类也可以传入。
• 泛型中有三种通配符形式：

• 无限制通配符：表示可以传入任意类型的参数

• 表示类型的上界是E，只能是E或者是E的子类

• 表示类型的下界是E，只能是E或者是E的父类

List<Animal> la = new ArrayList<>();
List<Dog> ld = new ArrayList<>();
System.out.println(la.add(new Animal())); // ok
System.out.println(la.add(new Dog()));     // ok ,可以添加子类
System.out.println(ld.add(new Dog()));    // ok
//System.out.println(ld.add(new Animal()));  // no
List<? extends Animal> lea = new ArrayList<>();
//System.out.println(lea.add(new Dog()));
List<? super Animal> lsa = new ArrayList<>();
lsa.add(new Dog());
lsa.add(new Animal());

4.8 Set集合

4.8.1 基本概念

• java.util.Set集合是Collection集合的子集合，与List集合平级。
• 该集合中元素没有先后放入次序，且不允许重复。
• 该集合的主要实现类是：HashSet类 和 TreeSet类以及LinkedHashSet类。
• 其中HashSet类的底层是采用哈希表进行数据管理的。
• 其中TreeSet类的底层是采用红黑树进行数据管理的。
• 其中LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。

4.8.2 元素放入HashSet的原理

• 使用元素调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算出该元素在数组中的索引位置。
• 若该位置没有元素，则将该元素直接放入即可。
• 若该位置有元素，则使用新元素与已有元素依次比较哈希值，若哈希值不相同，则将该元素插入到已有元素的后面。
• 若新元素与已有元素的哈希值相同，则使用新元素调用equals方法与已有元素依次比较。 若相等则添加元素失败，否则将元素直接放入后面即可。

4.8.3 TreeSet集合

• 二叉树主要指每个节点最多只有两个子节点的树形结构。

• 满足以下3个特征的二叉树叫做有序二叉树。

  • a.左子树中的任意节点元素都小于根节点元素值；
  • b.右子树中的任意节点元素都大于根节点元素值；
  • c.左子树和右子树的内部也遵守上述规则；
• 由于TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使用新元素与集合中已有的元素依次比较来确定新元素的合理位置。

• 比较元素大小的规则有两种方式：

  • 使用元素的自然排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口；
  • 使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口；
• 自然排序的规则比较单一，而比较器的规则比较多元化，而且比较器优先于自然排序；

Comparator<Student> comparator = (Student o1, Student o2) -> { return o1.getAge() - o2.getAge(); };
Set<Student> s2 = new TreeSet<>(comparator);

4.9 Map集合

4.9.1 基本概念

• java.util.Map集合中存取元素的基本单位是：单对元素，其中类型参数如下：

  • K - 此映射所维护的键(Key)的类型，相当于目录。
  • V - 映射值(Value)的类型，相当于内容。
• 该集合中key是不允许重复的，而且一个key只能对应一个value。
• 该集合的主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、 Properties类。
• 其中HashMap类的底层是采用哈希表进行数据管理的。
• 其中TreeMap类的底层是采用红黑树进行数据管理的。
• 其中LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。

• 其中Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null作为key或者value的数值。

  • 其中Properties类是Hashtable类的子类，该对象用于处理属性文件，key和value都是String类型的。
• Map集合是面向查询优化的数据结构, 在大数据量情况下有着优良的查询性能。经常用于根据key检索value的业务场景。

4.9.2 常用方法

4.9.3 元素放入HashMap集合的原理

• 使用元素的key调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算在数组中的索引位置。
• 若该位置没有元素，则将该键值对直接放入即可。
• 若该位置有元素，则使用key与已有元素依次比较哈希值，若哈希值不相同，则将该元素放到后面。
• 若key与已有元素的哈希值相同，则使用key调用equals方法与已有元素依次比较。 若相等则将对应的value修改，否则将键值对直接放入即可。

HashMap<Integer, String> map = new HashMap<>();
map.put(1,"one");
map.put(2,"two");
map.put(3,"three");
Set<Map.Entry<Integer, String>> entries = map.entrySet();
for (Map.Entry<Integer, String> kv : map.entrySet()) {
    System.out.println(kv.getKey() + ":" + kv.getValue());
}

4.9.4 相关常量

• DEFAULT_INITIAL_CAPACITY : HashMap的默认容量是16。
• DEFAULT_LOAD_FACTOR：HashMap的默认加载因子是0.75。
• threshold：扩容的临界值，该数值为：容量*填充因子，也就是12。
• TREEIFY_THRESHOLD：若Bucket中链表长度大于该默认值则转化为红黑树存储，该数值是8。
• MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量，该数值是64。

4.10 Collection类

java.util.Collections类主要提供了对集合操作或者返回集合的静态方法

常用方法