这篇博客详细介绍了JAVA核心库类，包括常用包的功能，如java.lang、java.util、java.io等。重点讲解了Object类、包装类（Integer、Double、Boolean、Character）的概念、方法和使用。此外，还涵盖了Math类、BigDecimal和BigInteger的数学处理，以及String类的特性。博客中还讨论了可变字符串StringBuilder和日期相关类，包括Java8之前的Date和新引入的Java8日期API。最后，简述了集合框架，如Collection、List、Queue、Set和Map的概述和主要方法。
文章目录
三、JAVA核心库类（上）
1. 常用类的概述和使用
1.1 常用的包
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类的概述
1.2.1 基本概念
java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间接子类。
如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类。
Object类定义了“对象”的基本行为, 被子类默认继承。
1.2.2 常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| Object() | 使用无参方式构造对象 |
| boolean equals(Object obj) | 用于判断调用对象是否与参数对象相等。 该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致 若希望比较两个对象的内容，则需要重写该方法。 若该方法被重写后，则应该重写hashCode方法来保证结果的一致 性。 |
| int hashCode() | 用于获取调用对象的哈希码值(内存地址的编号)。 若两个对象调用equals方法相等，则各自调用该方法的结果必须相 同 若两个调用对象equals方法不相等，则各自调用该方法的结果应该 不相同。 为了使得该方法与equals方法保持一致，需要重写该方法。 |
| String toString() | 用于获取调用对象的字符串形式 该方法默认返回的字符串为：包名.类名@哈希码值的十六进制 为了返回更有意义的数据，需要重写该方法 使用print或println打印引用或字符串拼接引用都会自动调用该方法 |
| Class<?> getClass() | 用于返回调用对象执行时的Class实例，反射机制使用 |
案例：重写equals方法
@Override
public boolean equals(Object obj) {
// 当调用对象和参数对象指向同一个对象时，则内容一定相同
if (this == obj) return true;
// 当调用对象为不为空而参数对象为空时，则内容一定不相同
if (null == obj) return false;
// 判断obj指向的对象是否为Student类型的对象，若是则条件成立，否则条件不成立
if (obj instanceof Student) {
Student ts = (Student) obj;
// 以学号作为基准判断两个对象是否相等 int是基本数据类型，内存空间中放的就是数据本身，使用 == 可以判断数据是否相同
//return this.getId() == ts.getId();
// 以姓名作为基准判断两个对象是否相等 String是引用数据类型，内存空间中放的是地址，使用 == 判断地址是否相同
// 也就是判断两个对象中姓名字符串的地址是否相同，不够完美
//return this.getName() == ts.getName();
return this.getName().equals(ts.getName()); // 比较姓名字符串的内容是否相同
}
// 否则类型不一致没有可比性，则内容一定不相同
return false;
}
*/
/**
* 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
*/
/*
@Override
public int hashCode() {
//return getId(); // 不再代表内存地址的编号了
final int type = 2;
//return type*31 + getId();
return type*31 + getName().hashCode();
}
*/
/**
* 为了返回更有意义的字符串数据，则需要重写该方法
*/
/*
@Override
public String toString() {
return "Student[id = " + getId() + ", name = " + getName() + "]";
}
*/
}
1.3 包装类
1.3.1 包装类的概念
通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。
1.3.2 包装类的分类
| 包装类 | 对应的基本类型 |
|---|---|
| java.lang.Byte | byte |
| java.lang.Short | short |
| java.lang.Integer | int |
| java.lang.Long | long |
| java.lang.Float | float |
| java.lang.Double | double |
| java.lang.Boolean | boolean |
| java.lang.Character | char |
1.3.3 Integer类的概述
（1）基本概念
java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。
（2）常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
| public static final int MAX_VALUE | 表示int类型可以描述的最大值，即2^31-1 |
| public static final int MIN_VALUE | 表示int类型可以描述的最小值，即-2^31 |
| public static final int SIZE | 表示int类型采用二进制补码形式的位数 |
| public static final int BYTES | 表示int类型所占的字节个数 |
| public static final Class TYPE | 表示int类型的Class实例 |
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| Integer(int value) | 根据参数指定的整数来构造对象（已过时） |
| Integer(String s) | 根据参数指定的字符串来构造对象 （已过时） |
| int intValue() | 获取调用对象中的整数值并返回 |
| static Integer valueOf(int i) | 根据参数指定整数值得到Integer类型对象 |
| boolean equals(Object obj) | 比较调用对象与参数指定的对象是否相等 |
| String toString() | 返回描述调用对象数值的字符串形式 |
| static int parseInt(String s) | 将字符串类型转换为int类型并返回 |
| static String toString(int i) | 获取参数指定整数的十进制字符串形式 |
| static String toBinaryString(int i) | 获取参数指定整数的二进制字符串形式 |
| static String toHexString(int i) | 获取参数指定整数的十六进制字符串形式 |
| static String toOctalString(int i) | 获取参数指定整数的八进制字符串形式 |
（3）装箱和拆箱的概念
在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。从Java5开始增加了自动拆箱和自动装箱的功能。
（4）自动装箱池
在Integer类的内部提供了自动装箱池技术，将-28到27之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。
1.3.4 Double类的概述
（1）基本概念
java.lang.Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double类型的包装并提供double类型到String类之间的转换等方法。
（2）常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
| public static final int SIZE | 表示double类型的二进制位数 |
| public static final int BYTES | 表示double类型的字节个数 |
| public static final Class TYPE | 表示double类型的Class实例 |
（3）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| Double(double value) | 根据参数指定的浮点数据来构造对象（已过时） |
| Double(String s) | 根据参数指定的字符串来构造对象 （已过时） |
| double doubleValue() | 获取调用对象中的浮点数据并返回 |
| static Double valueOf(double d) | 根据参数指定浮点数据得到Double类型对象 |
| boolean equals(Object obj) | 比较调用对象与参数指定的对象是否相等 |
| String toString() | 返回描述调用对象数值的字符串形式 |
| static double parseDouble(String s) | 将字符串类型转换为double类型并返回 |
| boolean isNaN() | 判断调用对象的数值是否为非数字 |
扩展：
java.lang.Number类是个抽象类，是上述类的父类来描述所有类共有的成员。
1.3.5 Boolean类的概述
（1）基本概念
java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对boolean类型的包装并提供boolean类型到String类之间的转换等方法。
（2）常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
| public static final Boolean FALSE | 对应基值为false的对象 |
| public static final Boolean TRUE | 对应基值为true的对象 |
| public static final Class TYPE | 表示boolean类型的Class实例 |
（3）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| Boolean(boolean value) | 根据参数指定的布尔数值来构造对象（已过时） |
| Boolean(String s) | 根据参数指定的字符串来构造对象 （已过时） |
| boolean booleanValue() | 获取调用对象中的布尔数值并返回 |
| static Boolean valueOf(boolean b) | 根据参数指定布尔数值得到Boolean类型对象 |
| boolean equals(Object obj) | 比较调用对象与参数指定的对象是否相等 |
| String toString() | 返回描述调用对象数值的字符串形式 |
| static boolean parseBoolean(String s) | 将字符串类型转换为boolean类型并返回 |
1.3.6 Character类的概述
（1）基本概念
java.lang.Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型的包装并提供字符类别的判断和转换等方法。
（2）常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
| public static final int SIZE | 表示char类型的二进制位数 |
| public static final int BYTES | 表示char类型的字节个数 |
| public static final Class TYPE | 表示char类型的Class实例 |
（3）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| Character(char value) | 根据参数指定的字符数据来构造对象（已过时） |
| char charValue() | 获取调用对象中的字符数据并返回 |
| static Character valueOf(char c) | 根据参数指定字符数据得到Character类型对象 |
| boolean equals(Object obj) | 比较调用对象与参数指定的对象是否相等 |
| String toString() | 返回描述调用对象数值的字符串形式 |
| static boolean isUpperCase(char ch) | 判断参数指定字符是否为大写字符 |
| static boolean isLowerCase(char ch) | 判断参数指定字符是否为小写字符 |
| static boolean isDigit(char ch) | 判断参数指定字符是否为数字字符 |
| static char toUpperCase(char ch) | 将参数指定的字符转换为大写字符 |
| static char toLowerCase(char ch) | 将参数指定的字符转换为小写字符 |
1.3.7 包装类（Wrapper）的使用总结
基本数据类型转换为对应包装类的方式
调用包装类的构造方法或静态方法即可
获取包装类对象中基本数据类型变量数值的方式
调用包装类中的xxxValue方法即可
字符串转换为基本数据类型的方式
调用包装类中的parseXxx方法即可
1.4 数学处理类
1.4.1 Math类的概述
（1）基本概念
java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static int max(int a, int b) | 返回两个参数中的最大值 |
| static int min(int a, int b) | 返回两个参数中的最小值 |
| static double pow(double a, double b) | 返回第一个参数的幂 |
| static int abs(int a) | 返回参数指定数值的绝对值 |
| static long round(double a) | 返回参数四舍五入的结果 |
| static double sqrt(double a) | 返回参数的平方根 |
| static double random() | 返回0.0到1.0的随机数 |
1.4.2 BigDecimal类的概述
（1）基本概念
由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助
java.math.BigDecimal类型加以描述。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| BigDecimal(String val) | 根据参数指定的字符串来构造对象 |
| BigDecimal add(BigDecimal augend) | 用于实现加法运算 |
| BigDecimal subtract(BigDecimal subtrahend) | 用于实现减法运算 |
| BigDecimal multiply(BigDecimal multiplicand) | 用于实现乘法运算 |
| BigDecimal divide(BigDecimal divisor) | 用于实现除法运算 |
1.4.3 BigInteger类的概念
（1）基本概念
若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| BigInteger(String val) | 根据参数指定的字符串来构造对象 |
| BigInteger add(BigInteger val) | 用于实现加法运算 |
| BigInteger subtract(BigInteger val) | 用于实现减法运算 |
| BigInteger multiply(BigInteger val) | 用于实现乘法运算 |
| BigInteger divide(BigInteger val) | 用于实现除法运算 |
| BigInteger remainder(BigInteger val) | 用于实现取余运算 |
| BigInteger[] divideAndRemainder(BigInteger val) | 用于实现取商和余数的运算 |
2. String类的概述和使用
2.1 String类的概念
java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如：“abc”。
该类由final关键字修饰，表示该类不能被继承。
从jdk1.9开始该类的底层不使用char[]来存储数据，而是改成 byte[]加上编码标记，从而节约了一些空间。
该类描述的字符串内容是个常量不可更改，因此可以被共享使用。
如：
String str1 = “abc”; - 其中"abc"这个字符串是个常量不可改变。
str1 = “23”; - 将“23”字符串的地址赋值给变量str1。
- 改变str1的指向并没有改变指向的内容
2.2 常量池的概念
由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象，从而提高了性能。
String类型引用指向的改变
2.3 常用的构造方法
| 方法声明 | 功能介绍 |
|---|---|
| String() | 使用无参方式构造对象得到空字符序列 |
| String(byte[] bytes, int offset, int length) | 使用bytes数组中下标从offset位置开始的length个字节来 构造对象 |
| String(byte[] bytes) | 使用bytes数组中的所有内容构造对象 |
| String(char[] value, int offset, int count) | 使用value数组中下标从offset位置开始的count个字符来构 造对象 |
| String(char[] value) | 使用value数组中的所有内容构造对象 |
| String(String original) | 根据参数指定的字符串内容来构造对象，新创建对象为参 数对象的副本 |
2.4 常用的成员方法
| 方法声明 | 功能介绍 |
|---|---|
| String toString() | 返回字符串本身 |
| byte[] getBytes() | 将当前字符串内容转换为byte数组并返回 |
| char[] toCharArray() | 用于将当前字符串内容转换为char数组并返回 |
| 方法声明 | 功能介绍 |
|---|---|
| char charAt(int index) | 方法charAt用于返回字符串指定位置的字符。 |
| int length() | 返回字符串字符序列的长度 |
| boolean isEmpty() | 判断字符串是否为空 |
案例题目
判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文是指一个字符序列无论从左向右读还是从右向左读都是相同的句子。
public class StringJudgeTest {
public static void main(String[] args) {
// 1.创建字符串对象并打印
String str1 = new String("上海自来水来自海上");
System.out.println("str1 = " + str1); // 上海自来水来自海上 9
// 2.判断该字符串内容是否为回文并打印
for (int i = 0; i < str1.length()/2; i++) {
if (str1.charAt(i) != str1.charAt(str1.length()-i-1)) { // 0和8 1和7 2和6 3和5
System.out.println(str1 + "不是回文！");
return; // 仅仅是用于实现方法的结束
}
}
System.out.println(str1 + "是回文！");
}
}
| 方法声明 | 功能介绍 |
|---|---|
| int compareTo(String anotherString) | 用于比较调用对象和参数对象的大小关系 |
| int compareToIgnoreCase(String str) | 不考虑大小写，也就是’a’和’A’是相等的关系 |
案例题目
编程实现字符串之间大小的比较并打印。
public class StringCompareTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("hello");
System.out.println("str1 = " + str1); // hello
// 2.使用构造好的对象与其它字符串对象之间比较大小并打印
System.out.println(str1.compareTo("world")); // 'h' - 'w' => 104 - 119 => -5
System.out.println(str1.compareTo("haha")); // 'e' - 'a' => 101 - 97 => 4
System.out.println(str1.compareTo("hehe")); // 'l' - 'h' => 108 - 104 => 4
System.out.println(str1.compareTo("heihei")); // 'l' - 'i' => 108 - 105 => 3
System.out.println(str1.compareTo("helloworld")); // 长度： 5 - 10 => -5
System.out.println(str1.compareToIgnoreCase("HELLO")); // 0
}
}
| 方法声明 | 功能介绍 |
|---|---|
| String concat(String str) | 用于实现字符串的拼接 |
| boolean contains(CharSequence s) | 用于判断当前字符串是否包含参数指定的内容 |
| String toLowerCase() | 返回字符串的小写形式 |
| String toUpperCase() | 返回字符串的大写形式 |
| String trim() | 返回去掉前导和后继空白的字符串 |
| boolean startsWith(String prefix) | 判断字符串是否以参数字符串开头 |
| boolean startsWith(String prefix, int toffset) | 从指定位置开始是否以参数字符串开头 |
| boolean endsWith(String suffix) | 判断字符串是否以参数字符串结尾 |
案例题目
编程实现上述方法的使用。
| 方法声明 | 功能介绍 |
|---|---|
| boolean equals(Object anObject) | 用于比较字符串内容是否相等并返回 |
| int hashCode() | 获取调用对象的哈希码值 |
| boolean equalsIgnoreCase(String anotherString) | 用于比较字符串内容是否相等并返回，不考虑大小写， 如：'A’和’a’是相等 |
案例题目
提示用户从键盘输入用户名和密码信息，若输入”admin”和”23456”则提示“登录成功，欢迎使用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已冻结，请联系客服人员！”
public class StringEqualsTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
for (int i = 3; i > 0; i--) {
// 1.提示用户从键盘输入用户名和密码信息并使用变量记录
System.out.println("请输入您的用户名和密码信息：");
String userName = sc.next();
String password = sc.next();
// 2.判断用户名和密码是否为"admin"和"123456"并给出提示
//if ("admin".equals(userName) && "123456".equals(password)) {
if ("admin".equalsIgnoreCase(userName) && "123456".equals(password)) { // 防止空指针异常
System.out.println("登录成功，欢迎使用！");
break;
} //else {
if (1 == i) {
System.out.println("账户已冻结，请联系客服人员！");
} else {
System.out.println("用户名或密码错误，您还有" + (i - 1) + "次机会！");
}
//}
}
// 关闭扫描器
sc.close();
}
}
| 方法声明 | 功能介绍 |
|---|---|
| int indexOf(int ch) | 用于返回当前字符串中参数ch指定的字符第一次出现的 下标 |
| int indexOf(int ch, int fromIndex) | 用于从fromIndex位置开始查找ch指定的字符 |
| int indexOf(String str) | 在字符串中检索str返回其第一次出现的位置，若找不到 返回-1 |
| int indexOf(String str, int fromIndex) | 表示从字符串的fromIndex位置开始检索str第一次出现 的位置 |
| int lastIndexOf(int ch) | 用于返回参数ch指定的字符最后一次出现的下标 |
| int lastIndexOf(int ch, int fromIndex) | 用于从fromIndex位置开始查找ch指定字符出现的下标 |
| int lastIndexOf(String str) | 返回str指定字符串最后一次出现的下标 |
| int lastIndexOf(String str, int fromIndex) | 用于从fromIndex位置开始反向搜索的第一次出现的下 标。 |
案例题目
编写通用的代码可以查询字符串"Good Good Study, Day Day Up!"中所有"Day"出现的索引位置并打印出来。
| 方法声明 | 功能介绍 |
|---|---|
| int indexOf(int ch) | 用于返回当前字符串中参数ch指定的字符第一次出现的 下标 |
| int indexOf(int ch, int fromIndex) | 用于从fromIndex位置开始查找ch指定的字符 |
| int indexOf(String str) | 在字符串中检索str返回其第一次出现的位置，若找不到 返回-1 |
| int indexOf(String str, int fromIndex) | 表示从字符串的fromIndex位置开始检索str第一次出现 的位置 |
| int lastIndexOf(int ch) | 用于返回参数ch指定的字符最后一次出现的下标 |
| int lastIndexOf(int ch, int fromIndex) | 用于从fromIndex位置开始查找ch指定字符出现的下标 |
| int lastIndexOf(String str) | 返回str指定字符串最后一次出现的下标 |
| int lastIndexOf(String str, int fromIndex) | 用于从fromIndex位置开始反向搜索的第一次出现的下 标。 |
案例题目
提示用户从键盘输入一个字符串和一个字符，输出该字符(不含)后面的所有子字符串。
public class SubStringTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("Happy Wife, Happy Life!");
System.out.println("str1 = " + str1); // Happy Wife, Happy Life!
// 2.获取字符串中的一部分内容并打印
// 表示从当前字符串中下标12开始获取子字符串
String str2 = str1.substring(12);
System.out.println("str2 = " + str2); // Happy Life!
// 可以取到6但是取不到10
String str3 = str1.substring(6, 10);
System.out.println("str3 = " + str3); // Wife
System.out.println("---------------------------------------------------------");
// 3.获取输入字符串中从输入字符起的子字符串内容
System.out.println("请输入一个字符串：");
Scanner sc = new Scanner(System.in);
String str4 = sc.next();
System.out.println("请输入一个字符：");
String str5 = sc.next();
// 从str4中查找str5第一次出现的索引位置
int pos = str4.indexOf(str5);
System.out.println("pos = " + pos);
// 根据该位置获取子字符串
String str6 = str4.substring(pos+1);
System.out.println("获取到的子字符串是：" + str6);
}
}
2.5 正则表达式的概念
正则表达式本质就是一个“规则字符串”，可以用于对字符串数据的格式进行验证，以及匹配、查找、替换等操作。该字符串通常使用^运算符作为开头标志，使用$运算符作为结尾标志，当然也可以省略。
2.6 正则表达式的规则
| 正则表达式 | 说明 |
|---|---|
| [abc] | 可以出现a、b、c中任意一个字符 |
| [^abc] | 可以出现任何字符，除了a、b、c的任意字符 |
| [a-z] | 可以出现a、b、c、……、z中的任意一个字符 |
| [a-zA-Z0-9] | 可以出现az、AZ、0~9中任意一个字符 |
| 正则表达式 | 说明 |
|---|---|
| . | 任意一个字符（通常不包含换行符） |
| \d | 任意一个数字字符，相当于[0-9] |
| \D | 任意一个非数字字符 |
| \s | 空白字符，相当于[\t\n\x0B\f\r] |
| \S | 非空白字符 |
| \w | 任意一个单词字符，相当于[a-zA-Z_0-9] |
| \W | 任意一个非单词字符 |
| 正则表达式 | 说明 |
|---|---|
| X? | 表示X可以出现一次或一次也没有，也就是0 ~ 1次 |
| X* | 表示X可以出现零次或多次，也就是0 ~ n次 |
| X+ | 表示X可以出现一次或多次，也就是1 ~ n次 |
| X{n} | 表示X可以出现恰好 n 次 |
| X{n，} | 表示X可以出现至少 n 次，也就是>=n次 |
| X{n，m} | 表示X可以出现至少 n 次，但是不超过 m 次，也就是>=n并且<=m次 |
2.7 正则表达式相关的方法
| 方法名称 | 方法说明 |
|---|---|
| boolean matches(String regex) | 判断当前正在调用的字符串是否匹配参数指定的正则表达式规 则 |
| 方法名称 | 方法说明 |
|---|---|
| String[] split(String regex) | 参数regex为正则表达式，以regex所表示的字符串为分隔 符，将字符串拆分成字符串数组 |
| String replace(char oldChar, char newChar) | 使用参数newChar替换此字符串中出现的所有参数 oldChar |
| String replaceFirst(String regex, String replacement) | 替换此字符串匹配给定的正则表达式的第一个子字符串 |
| String replaceAll(String regex, String replacement) | 将字符串中匹配正则表达式regex的字符串替换成 replacement |
3. 可变字符串类和日期相关类
3.1 可变字符串类
3.1.1 基本概念
由于String类描述的字符串内容是个常量不可改变，当需要在Java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费。
为了解决上述问题，可以使用java.lang.StringBuilder类和java.lang.StringBuffer类来描述字符序列可以改变的字符串，如：“ab”。
StringBuffer类是从jdk1.0开始存在，属于线程安全的类，因此效率比较低。
StringBuilder类是从jdk1.5开始存在，属于非线程安全的类，效率比较高。
3.1.2 StringBuilder类常用的构造方法
| 方法声明 | 功能介绍 |
|---|---|
| StringBuilder() | 使用无参方式构造对象，容量为16 |
| StringBuilder(int capacity) | 根据参数指定的容量来构造对象，容量为参数指定大小 |
| StringBuilder(String str) | 根据参数指定的字符串来构造对象，容量为：16+字符串长度 |
3.1.3 StringBuilder类常用的成员方法
| 方法声明 | 功能介绍 |
|---|---|
| int capacity() | 用于返回调用对象的容量 |
| int length() | 用于返回字符串的长度，也就是字符的个数 |
| StringBuilder insert(int offset, String str) | 插入字符串并返回调用对象的引用，就是自 己。 |
| StringBuilder append(String str) | 追加字符串 |
| StringBuilder deleteCharAt(int index) | 将当前字符串中下标为index位置的单个字符 删除 |
| StringBuilder delete(int start，int end) | 删除字符串 |
| StringBuilder replace(int start，int end， String str) | 替换字符串 |
| StringBuilder reverse() | 字符串反转 |
注意
作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder会改变其值。
3.1.4 返回值的设计
StringBuilder的很多方法的返回值均为StringBuilder类型。这些方法的返回语句均为：return this。
由此可见，这些方法在对StringBuilder所封装的字符序列进行改变后又返回了该对象的引用。基于这样设计的目的在于可以连续调用。
StringBuilder案例：
public class StringBuilderTest {
public static void main(String[] args) {
// 1.使用无参方式构造StringBuilder类型的对象并打印容量和长度
StringBuilder sb1 = new StringBuilder();
System.out.println("sb1 = " + sb1); // 自动调用toString方法 啥也没有
System.out.println("容量是：" + sb1.capacity()); // 16
System.out.println("长度是：" + sb1.length()); // 0
System.out.println("-----------------------------------------------------------");
// 2.使用参数指定的容量来构造对象并打印容量和长度
StringBuilder sb2 = new StringBuilder(20);
System.out.println("sb2 = " + sb2); // 自动调用toString方法 啥也没有
System.out.println("容量是：" + sb2.capacity()); // 20
System.out.println("长度是：" + sb2.length()); // 0
System.out.println("-----------------------------------------------------------");
// 3.根据参数指定的字符串内容来构造对象并打印容量和长度
StringBuilder sb3 = new StringBuilder("hello");
System.out.println("sb3 = " + sb3); // 自动调用toString方法 hello
System.out.println("容量是：" + sb3.capacity()); // 16 + 5 = 21
System.out.println("长度是：" + sb3.length()); // 5
System.out.println("-----------------------------------------------------------");
String str1 = new String("hello");
String str2 = str1.toUpperCase();
System.out.println("str2 = " + str2); // HELLO
System.out.println("str1 = " + str1); // hello 字符串本身是个常量不会改变
// 4.实现向字符串中插入和追加字符串内容
// 向下标为0的位置插入字符串内容"abcd"，也就是向开头位置插入字符串内容
StringBuilder sb4 = sb3.insert(0, "abcd");
System.out.println("sb4 = " + sb4); // abcdhello 返回调用对象自己的引用，也就是返回值和调用对象是同一个字符串
System.out.println("sb3 = " + sb3); // abcdhello
// 向中间位置插入字符串"1234"
sb3.insert(4, "1234");
System.out.println("sb3 = " + sb3); // abcd1234hello
// 向末尾位置插入字符串"ABCD"
sb3.insert(sb3.length(), "ABCD");
System.out.println("sb3 = " + sb3); // abcd1234helloABCD
System.out.println("-----------------------------------------------------------");
// 向末尾位置追加字符串内容
sb3.append("world");
System.out.println("sb3 = " + sb3); // abcd1234helloABCDworld
// 当字符串的长度超过了字符串对象的初始容量时，该字符串对象会自动扩容，默认扩容算法是：原始容量*2 + 2 => 21*2 + 2 => 44
// 底层采用byte数组来存放所有的字符内容。
// ctrl+alt+左右方向键 表示回到上/下一个位置
System.out.println("容量是：" + sb3.capacity()); // 44
System.out.println("长度是：" + sb3.length()); // 22
System.out.println("-----------------------------------------------------------");
// 5.实现字符串中字符和字符串的删除
// 表示删除下标为8的单个字符
sb3.deleteCharAt(8);
System.out.println("sb3 = " + sb3); // abcd1234elloABCDworld
// 使用for循环删除多个字符
for (int i = 8; i < 12; i++) {
// 由结果可知：删除一个字符后就跳过一个字符继续删除，因为每当删除一个字符后后面的字符会向前补位，因为下标会发生变化
//sb3.deleteCharAt(i);
// 始终删除下标为8的字符
sb3.deleteCharAt(8);
}
System.out.println("删除后的字符串是：" + sb3); // abcd1234ABCDworld
System.out.println("-----------------------------------------------------------");
// 删除起始字符串abcd，包含0但不包含4
sb3.delete(0, 4);
System.out.println("sb3 = " + sb3); // 1234ABCDworld
// 删除中间字符串
sb3.delete(4, 8);
System.out.println("sb3 = " + sb3); // 1234world
// 删除末尾字符串
sb3.delete(4, sb3.length());
System.out.println("sb3 = " + sb3); // 1234
System.out.println("-----------------------------------------------------------");
// 6.实现字符串内容的修改、查找以及反转操作
// 表示将下标为0这个位置的字符修改为'a'
sb3.setCharAt(0, 'a');
System.out.println("修改单个字符后的内容是：" + sb3); // a234
// 修改"234"为"bcd"
sb3.replace(1, 4, "bcd");
System.out.println("修改字符串后的结果是：" + sb3); // abcd
// 实现查找的功能
int pos = sb3.indexOf("b");
System.out.println("从前向后查找的结果是：" + pos); // 1
pos = sb3.lastIndexOf("b");
System.out.println("从后向前查找的结果是：" + pos); // 1
// 实现字符串的反转功能
sb3.reverse();
System.out.println("反转后的结果是：" + sb3); // dcba
System.out.println("-----------------------------------------------------------");
// 7.笔试考点
// 考点一：既然StringBuilder类的对象本身可以修改，那么为什么成员方法还有返回值呢？
// 解析：为了连续调用
//sb3.reverse().append("1").append("2").insert(0, "3").delete(0, 1).reverse();
// 考点二：如何实现StringBuilder类型和String类型之间的转换呢？
//String str3 = sb3.toString();
//StringBuilder sb5 = new StringBuilder(str3);
// 考点三：String、StringBuilder、StringBuffer之间效率谁高？排列如何？
// String < StringBuffer < StringBuilder
}
}
3.2 Java8之前的日期相关类
3.2.1 System类的概述
（1）基本概念
Java.lang.System类中提供了一些有用的类字段和方法。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static long currentTimeMillis() | 返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时 间差 |
3.2.2 Date类的概述
（1）基本概念
java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| Date() | 使用无参的方式构造对象，也就是当前系统时间 |
| Date(long date) | 根据参数指定毫秒数构造对象， 参数为距离1970年1月1日0时0分0秒 的毫秒数 |
| long getTime() | 获取调用对象距离1970年1月1日0时0分0秒的毫秒数 |
| void setTime(long time) | 设置调用对象为距离基准时间time毫秒的时间点 |
3.2.3 SimpleDateFormat类的概述
（1）基本概念
java.text.SimpleDateFormat类主要用于实现日期和文本之间的转换。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| SimpleDateFormat() | 使用无参方式构造对象 |
| SimpleDateFormat(String pattern) | 根据参数指定的模式来构造对象，模式主要有: y-年 M-月 d-日 H-时 m-分 s-秒 |
| final String format(Date date) | 用于将日期类型转换为文本类型 |
| Date parse(String source) | 用于将文本类型转换为日期类型 |
3.2.4 Calendar类的概述
（1）基本概念
java.util.Calender类主要用于描述特定的瞬间，取代Date类中的过时方法实现全球化。
该类是个抽象类，因此不能实例化对象，其具体子类针对不同国家的日历系统，其中应用最广泛的是GregorianCalendar（格里高利历），对应世界上绝大多数国家/地区使用的标准日历系统。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static Calendar getInstance() | 用于获取Calendar类型的引 用 |
| void set(int year, int month, int date, int hourOfDay, int minute, int second) | 用于设置年月日时分秒信息 |
| Date getTime() | 用于将Calendar类型转换为 Date类型 |
| void set(int field, int value) | 设置指定字段的数值 |
| void add(int field, int amount) | 向指定字段增加数值 |
（3）多态的使用场合
通过方法的参数传递形成多态；
public static void draw(Shape s){
s.show();
}
draw(new Rect(1, 2, 3, 4));
在方法体中直接使用多态的语法格式
Account acc = new FixedAccount();
通过方法的返回值类型形成多态
Calender getInstance(){
return new GregorianCalendar(zone, aLocale);
}
3.3 Java8中的日期相关类
3.3.1 Java8日期类的由来
JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：Date类中的年份是从1900开始的，而月份都从0开始。
格式化只对Date类有用，对Calendar类则不能使用。非线程安全等。
3.3.2 Java8日期类的概述
Java 8通过发布新的Date-Time API来进一步加强对 日期与时间的处理。
java.time包：该包日期/时间API的基础包。
java.time.chrono包：该包提供对不同日历系统的访问。
java.time.format包：该包能够格式化和解析日期时间对象。
java.time.temporal包：该包包含底层框架和扩展特性。
java.time.zone包：该包支持不同时区以及相关规则的类。
3.3.3 LocalDate类的概述
（1）基本概念
java.time.LocalDate类主要用于描述年-月-日格式的日期信息，该类不表示时间和时区信息。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static LocalDate now() | 在默认时区中从系统时钟获取当前日期 |
3.3.4 LocalTime类的概述
（1）基本概念
java.time.LocalTime 类主要用于描述时间信息，可以描述时分秒以及纳秒。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static LocalTime now() | 从默认时区的系统时间中获取当前时间 |
| static LocalTime now(ZoneId zone) | 获取指定时区的当前时间 |
3.3.5 LocalDateTime类的概述
（1）基本概念
java.time.LocalDateTime类主要用于描述ISO-8601日历系统中没有时区的日期时间，如2007-12-
03T10:5:30。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static LocalDateTime now() | 从默认时区的系统时间中获取 当前日期时间 |
| static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second) | 根据参数指定的年月日时分秒 信息来设置日期时间 |
| int getYear() | 获取年份字段的数值 |
| int getMonthValue() | 获取1到12之间的月份字段 |
| int getDayOfMonth() | 获取日期字段 |
| int getHour() | 获取小时数 |
| int getMinute() | 获取分钟数 |
| int getSecond() | 获取秒数 |
| LocalDateTime withYear(int year) | 设置为参数指定的年 |
| LocalDateTime withMonth(int month) | 设置为参数指定的月 |
| LocalDateTime withDayOfMonth(int dayOfMonth) | 设置为参数指定的日 |
| LocalDateTime withHour(int hour) | 设置为参数指定的时 |
| LocalDateTime withMinute(int minute) | 设置为参数指定的分 |
| LocalDateTime withSecond(int second) | 设置为参数指定的秒 |
| LocalDateTime plusYears(long years) | 加上参数指定的年 |
| LocalDateTime plusMonths(long months) | 加上参数指定的月 |
| LocalDateTime plusDays(long days) | 加上参数指定的日 |
| LocalDateTime plusHours(long hours) | 加上参数指定的时 |
| LocalDateTime plusMinutes(long minutes) | 加上参数指定的分 |
| LocalDateTime plusSeconds(long seconds) | 加上参数指定的秒 |
| LocalDateTime minusYears(long years) | 减去参数指定的年 |
| LocalDateTime minusMonths(long months) | 减去参数指定的月 |
| LocalDateTime minusDays(long days) | 减去参数指定的日 |
| LocalDateTime minusHours(long hours) | 减去参数指定的时 |
| LocalDateTime minusMinutes(long minutes) | 减去参数指定的分 |
| LocalDateTime minusSeconds(long seconds) | 减去参数指定的秒 |
3.3.6 Instant类的概述
（1）基本概念
java.time.Instant类主要用于描述瞬间的时间点信息。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static Instant now() | 从系统时钟上获取当前时间 |
| OffsetDateTime atOffset(ZoneOffset offset) | 将此瞬间与偏移量组合以创建偏移日期时间 |
| static Instant ofEpochMilli(long epochMilli) | 根据参数指定的毫秒数来构造对象，参数为距离1970年1月1 日0时0分0秒的毫秒数 |
| long toEpochMilli() | 获取距离1970年1月1日0时0分0秒的毫秒数 |
3.3.7 DateTimeFormatter类的概述
（1）基本概念
java.time.format.DateTimeFormatter类主要用于格式化和解析日期。
（2）常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static DateTimeFormatter ofPattern(String pattern) | 根据参数指定的模式来获取对象 |
| String format(TemporalAccessor temporal) | 将参数指定日期时间转换为字符串 |
| TemporalAccessor parse(CharSequence text) | 将参数指定字符串转换为日期时间 |
4. 集合类库（上）
4.1 集合的概述
4.1.1 集合的由来
当需要在Java程序中记录单个数据内容时，则声明一个变量。
当需要在Java程序中记录多个类型相同的数据内容时，声明一个一维数组。
当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。
当需要在Java程序中记录多个类型相同的对象数据时，创建一个对象数组。
当需要在Java程序中记录多个类型不同的对象数据时，则准备一个集合。
4.1.2 集合的框架结构
Java中集合框架顶层框架是：java.util.Collection集合 和 java.util.Map集合。
其中Collection集合中存取元素的基本单位是：单个元素。
其中Map集合中存取元素的基本单位是：单对元素。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-apulpAB0-1602853348276)(upload\image-20201016202022333.png)]
集合框架
4.2 Collection集合
4.2.1 基本概念
java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口，因此该接口里定义的方法既可用于操作List集合，也可用于操作Queue集合和Set集合。
4.2.1 常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| boolean add(E e); | 向集合中添加对象 |
| boolean addAll(Collection<? extends E> c) | 用于将参数指定集合c中的所有元素添加到当前集合 中 |
| boolean contains(Object o); | 判断是否包含指定对象 |
| boolean containsAll(Collection<?> c) | 判断是否包含参数指定的所有对象 |
| boolean retainAll(Collection<?> c) | 保留当前集合中存在且参数集合中存在的所有对象 |
| boolean remove(Object o); | 从集合中删除对象 |
| boolean removeAll(Collection<?> c) | 从集合中删除参数指定的所有对象 |
| void clear(); | 清空集合 |
| int size(); | 返回包含对象的个数 |
| boolean isEmpty(); | 判断是否为空 |
| boolean equals(Object o) | 判断是否相等 |
| int hashCode() | 获取当前集合的哈希码值 |
| Object[] toArray() | 将集合转换为数组 |
| Iterator iterator() | 获取当前集合的迭代器 |
public class CollectionTest {
public static void main(String[] args) {
// 1.准备一个Collection集合并打印
//Collection c1 = new Collection(); // 接口不能实例化，也就是不能创建对象
// 接口类型的引用指向实现类的对象，形成了多态
Collection c1 = new ArrayList();
// 自动调用toString方法，调用ArrayList类中的toString方法，默认打印格式为：[元素值1, 元素值2, ...]
System.out.println("集合中的元素有：" + c1); // [啥也没有]
System.out.println("--------------------------------------------------------");
// 2.向集合中添加单个元素并打印
boolean b1 = c1.add(new String("one"));
System.out.println("b1 = " + b1); // true
System.out.println("集合中的元素有：" + c1); // [one]
b1 = c1.add(Integer.valueOf(2));
System.out.println("b1 = " + b1); // true
System.out.println("集合中的元素有：" + c1); // [one, 2]
b1 = c1.add(new Person("zhangfei", 30));
System.out.println("b1 = " + b1); // true
// 打印集合中的所有元素时，本质上就是打印集合中的每个对象，也就是让每个对象调用对应类的toString方法
System.out.println("集合中的元素有：" + c1); // [one, 2, Person{name='zhangfei', age=30}]
System.out.println("--------------------------------------------------------");
// 3.向集合中添加多个元素并打印
Collection c2 = new ArrayList();
c2.add("three"); // 常量池
c2.add(4); // 自动装箱机制
System.out.println("c2 = " + c2); // [three, 4]
// 将c2中的所有元素全部添加到集合c1中，也就是将集合c2中的元素一个一个依次添加到集合c1中
b1 = c1.addAll(c2);
// 表示将集合c2整体看做一个元素添加到集合c1中
//b1 = c1.add(c2);
System.out.println("b1 = " + b1);
// [one, 2, Person{name='zhangfei', age=30}, three, 4] [one, 2, Person{name='zhangfei', age=30}, [three, 4]]
System.out.println("c1 = " + c1);
System.out.println("--------------------------------------------------------");
// 4.判断集合中是否包含参数指定的单个元素
b1 = c1.contains(new String("one"));
System.out.println("b1 = " + b1); // true
b1 = c1.contains(new String("two"));
System.out.println("b1 = " + b1); // false
b1 = c1.contains(Integer.valueOf(2));
System.out.println("b1 = " + b1); // true
b1 = c1.contains(Integer.valueOf(3));
System.out.println("b1 = " + b1); // false
// contains方法的工作原理是：Objects.equals(o, e)，其中o代表contains方法的形式参数，e代表集合中的每个元素
// 也就是contains的工作原理就是 拿着参数对象与集合中已有的元素依次进行比较，比较的方式调用Objects中的equals方法
// 而该方法equals的工作原理如下：
/*
public static boolean equals(Object a, Object b) { 其中a代表Person对象，b代表集合中已有的对象
return (a == b) || (a != null && a.equals(b));
元素包含的第一种方式就是：Person对象与集合中已有对象的地址相同
第二种方式就是：Person对象不为空，则Person对象调用equals方法与集合中已有元素相等
}
*/
// 当Person类中没有重写equals方法时，则调用从Object类中继承下来的equals方法，比较两个对象的地址 false
// 当Person类中重写equals方法后，则调用重写以后的版本，比较两个对象的内容 true
b1 = c1.contains(new Person("zhangfei", 30));
System.out.println("b1 = " + b1); // true false
System.out.println("--------------------------------------------------------");
// [one, 2, Person{name='zhangfei', age=30}, three, 4]
System.out.println("c1 = " + c1);
// 5.判断当前集合中是否包含参数指定集合的所有元素
Collection c3 = new ArrayList();
c3.add(4);
System.out.println("c3 = " + c3); // [4]
// 判断集合c1中是否包含集合c3中的所有元素
b1 = c1.containsAll(c3);
System.out.println("b1 = " + b1); // true
c3.add("five");
System.out.println("c3 = " + c3); // [4, five]
// 判断集合c1中是否包含集合c3中的所有元素，只有集合c3中的所有元素都在集合c1中出现才会返回true，否则都是false
b1 = c1.containsAll(c3);
System.out.println("b1 = " + b1); // false
// 笔试考点
System.out.println("c2 = " + c2); // [three, 4]
b1 = c1.containsAll(c2);
System.out.println("b1 = " + b1); // true false
// 判断集合c1中是否拥有集合c2这个整体为单位的元素
b1 = c1.contains(c2);
System.out.println("b1 = " + b1); // false true
System.out.println("--------------------------------------------------------");
// 6.计算两个集合的交集并保留到当前集合中
System.out.println("c2 = " + c2); // [three, 4]
System.out.println("c3 = " + c3); // [4, five]
// 也就是让集合自己和自己取交集，还是自己，也就是当前集合中的元素没有发生改变
b1 = c2.retainAll(c2);
System.out.println("b1 = " + b1); // false 表示当前集合中的元素没有发生改变
System.out.println("c2 = " + c2); // [three, 4]
// 计算集合c2和c3的交集并保留到集合c2中，取代集合c2中原有的数值
b1 = c2.retainAll(c3);
System.out.println("b1 = " + b1); // true 当前集合的元素发生了改变
System.out.println("c2 = " + c2); // [4]
System.out.println("c3 = " + c3); // [4, five]
System.out.println("--------------------------------------------------------");
// 7.实现集合中单个元素的删除操作
// [one, 2, Person{name='zhangfei', age=30}, three, 4]
System.out.println("c1 = " + c1);
// 删除参数指定的单个元素
b1 = c1.remove(1);
System.out.println("b1 = " + b1); // false
// [one, 2, Person{name='zhangfei', age=30}, three, 4]
System.out.println("c1 = " + c1);
b1 = c1.remove("one");
System.out.println("b1 = " + b1); // true
// [2, Person{name='zhangfei', age=30}, three, 4]
System.out.println("c1 = " + c1);
// remove方法的工作原理：Objects.equals(o, e)
b1 = c1.remove(new Person("zhangfei", 30));
System.out.println("b1 = " + b1); // true
// [2, three, 4]
System.out.println("c1 = " + c1);
System.out.println("--------------------------------------------------------");
// 8.实现集合中所有元素的删除操作
System.out.println("c3 = " + c3); // [4, five]
// 从集合c1中删除集合c3中的所有元素，本质上就是一个一个元素进行删除，有元素则删除，否则不删除
b1 = c1.removeAll(c3);
System.out.println("b1 = " + b1); // true
// [2, three]
System.out.println("c1 = " + c1);
System.out.println("c3 = " + c3); // [4, five]
// 笔试考点 删除整体对象c3
b1 = c1.remove(c3);
System.out.println("b1 = " + b1); // false
System.out.println("c1 = " + c1); // [2, three]
System.out.println("--------------------------------------------------------");
// 9.实现集合中其它方法的测试 ctrl+n 可以直接搜索并打开类的源码 使用ctrl+f12可以搜索类中的方法
System.out.println("集合中元素的个数为：" + c1.size()); // 2
System.out.println(0 == c1.size() ? "集合已经空了": "集合还没有空"); // 没有空
System.out.println(c1.isEmpty()? "集合已经空了": "集合还没有空"); // 没有空
// 清空集合中的所有元素
c1.clear();
System.out.println("集合中元素的个数为：" + c1.size()); // 0
System.out.println(0 == c1.size() ? "集合已经空了": "集合还没有空"); // 已经空了
System.out.println(c1.isEmpty()? "集合已经空了": "集合还没有空"); // 已经空了
// 准备两个集合并判断是否相等
Collection c4 = new ArrayList();
c4.add(1);
c4.add(2);
System.out.println("c4 = " + c4); // [1, 2]
Collection c5 = new ArrayList();
c5.add(1);
c5.add(2);
c5.add(3);
System.out.println("c5 = " + c5); // [1, 2, 3]
// 判断是否相等
b1 = c4.equals(c5);
System.out.println("b1 = " + b1); // true false
System.out.println("--------------------------------------------------------");
// 10.实现集合和数组类型之间的转换 通常认为：集合是用于取代数组的结构
// 实现集合向数组类型的转换
Object[] objects = c5.toArray();
// 打印数组中的所有元素
System.out.println("数组中的元素有：" + Arrays.toString(objects)); // [1, 2, 3]
// 实现数组类型到集合类型的转换
Collection objects1 = Arrays.asList(objects);
System.out.println("集合中的元素有：" + objects1); // [1, 2, 3]
}
}
4.3 Iterator接口
4.3.1 基本概念
java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素。
java.util.Collection接口继承Iterator接口，因此所有实现Collection接口的实现类都可以使用该迭代器对象。
4.3.2 常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| boolean hasNext() | 判断集合中是否有可以迭代/访问的元素 |
| E next() | 用于取出一个元素并指向下一个元素 |
| void remove() | 用于删除访问到的最后一个元素 |
案例题目：
如何使用迭代器实现toString方法的打印效果？
public class CollectionPrintTest {
public static void main(String[] args) {
// 1.准备一个Collection集合并放入元素后打印
Collection c1 = new ArrayList();
c1.add("one");
c1.add(2);
c1.add(new Person("zhangfei", 30));
// 遍历方式一： 自动调用toString方法 String类型的整体
System.out.println("c1 = " + c1); // [one, 2, Person{name='zhangfei', age=30}]
System.out.println("------------------------------------------------");
// 2.遍历方式二：使用迭代器来遍历集合中的所有元素 更加灵活
// 2.1 获取当前集合中的迭代器对象
Iterator iterator1 = c1.iterator();
/*
// 2.2 判断是否有元素可以访问
System.out.println(iterator1.hasNext()); // true
// 2.3 取出一个元素并指向下一个
System.out.println("获取到的元素是：" + iterator1.next()); // one
System.out.println(iterator1.hasNext()); // true
System.out.println("获取到的元素是：" + iterator1.next()); // 2
System.out.println(iterator1.hasNext()); // true
System.out.println("获取到的元素是：" + iterator1.next()); // Person{name='zhangfei', age=30}
System.out.println(iterator1.hasNext()); // false
System.out.println("获取到的元素是：" + iterator1.next()); // 编译ok，运行发生NoSuchElementException没有这样的元素异常
*/
while (iterator1.hasNext()) {
System.out.println("获取到的元素是：" + iterator1.next());
}
System.out.println("------------------------------------------------");
// 由于上个循环已经使得迭代器走到了最后，因此需要重置迭代器
iterator1 = c1.iterator();
// 3.使用迭代器来模拟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);
System.out.println("------------------------------------------------");
// 4.不断地去获取集合中的元素并判断，当元素值为"one"时则删除该元素
iterator1 = c1.iterator();
while (iterator1.hasNext()) {
Object obj = iterator1.next();
if("one".equals(obj)) {
iterator1.remove(); //使用迭代器的remove方法删除元素没问题
//c1.remove(obj); // 使用集合的remove方法编译ok，运行发生ConcurrentModificationException并发修改异常
}
}
System.out.println("删除后集合中的元素有：" + c1); // [2, Person{name='zhangfei', age=30}]
System.out.println("------------------------------------------------");
// 5.使用 for each结构实现集合和数组中元素的遍历 代码简单且方法灵活
// 由调试源码可知：该方式确实是迭代器的简化版
for (Object obj : c1) {
System.out.println("取出来的元素是：" + obj);
}
int[] arr = new int[] {11, 22, 33, 44, 55};
for (int i : arr) {
System.out.println("i = " + i);
i = 66; // 修改局部变量i的数值，并不是修改数组中元素的数值
}
System.out.println("数组中的元素有：" + Arrays.toString(arr));
}
}
4.4 for each循环
4.4.1 基本概念
Java5推出了增强型for循环语句，可以应用数组和集合的遍历。
是经典迭代的“简化版”。
4.4.2 语法格式
for(元素类型 变量名 : 数组/集合名称) {
循环体;
}
4.4.3 执行流程
不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止。
4.5 List集合
4.5.1 基本概念
java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。
该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类。
其中ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。
其中LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删元素方便。
ArrayList底层原理
可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别。
LinkList底层原理
其中Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LIFO)。
其中Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的类，效率比较低，以后开发中基本不用。
4.5.2 常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| void add(int index, E element) | 向集合中指定位置添加元素 |
| boolean addAll(int index, Collection<? extends E> c) | 向集合中添加所有元素 |
| E get(int index) | 从集合中获取指定位置元素 |
| int indexOf(Object o) | 查找参数指定的对象 |
| int lastIndexOf(Object o) | 反向查找参数指定的对象 |
| E set(int index, E element) | 修改指定位置的元素 |
| E remove(int index) | 删除指定位置的元素 |
| List subList(int fromIndex, int toIndex) | 用于获取子List |
public class ListMethodTest {
public static void main(String[] args) {
// 1.准备一个List集合并打印
List lt1 = new LinkedList();
System.out.println("lt1 = " + lt1); // [啥也没有]
System.out.println("------------------------------------------");
// 2.向集合中添加元素并打印
// 向集合中的开头位置添加元素
lt1.add(0, "one");
System.out.println("lt1 = " + lt1); // [one]
// 向集合中的末尾位置添加元素
lt1.add(1, 3);
System.out.println("lt1 = " + lt1); // [one, 3]
// 向集合中的中间位置添加元素
lt1.add(1, "two");
System.out.println("lt1 = " + lt1); // [one, two, 3]
System.out.println("------------------------------------------");
// 3.根据参数指定的下标来获取元素
String str1 = (String) lt1.get(0);
System.out.println("获取到的元素是：" + str1); // one
// 注意：获取元素并进行强制类型转换时一定要慎重，因为容易发生类型转换异常
//String str2 = (String)lt1.get(2); // 编译ok，运行发生ClassCastException类型转换异常
//System.out.println("获取到的元素是：" + str2); // 3
System.out.println("------------------------------------------");
// 4.使用get方法获取集合中的所有元素并打印
StringBuilder sb1 = new StringBuilder();
sb1.append("[");
for (int i = 0; i < lt1.size(); i++) {
//Object obj = lt1.get(i);
//System.out.println("获取到的元素是：" + obj);
Object obj = lt1.get(i);
// 若取出的元素是最后一个元素，则拼接元素值和]
if (lt1.size()-1 == i) {
sb1.append(obj).append("]");
}
// 否则拼接元素和逗号以及空格
else {
sb1.append(obj).append(",").append(" ");
}
}
System.out.println("lt1 = " + sb1); // [one, two, 3]
System.out.println("------------------------------------------");
// 5.查找指定元素出现的索引位置
System.out.println("one第一次出现的索引位置为：" + lt1.indexOf("one")); // 0
lt1.add("one");
System.out.println("lt1 = " + lt1); // [one, two, 3, one]
System.out.println("one反向查找第一次出现的索引位置是：" + lt1.lastIndexOf("one")); // 3
System.out.println("------------------------------------------");
System.out.println("lt1 = " + lt1); // [one, two, 3, one]
// 6.实现集合中元素的修改
Integer it1 = (Integer) lt1.set(2, "three");
System.out.println("被修改的元素是：" + it1); // 3
System.out.println("修改后集合中的元素有：" + lt1); // [one, two, three, one]
String str2 = (String) lt1.set(3, "four");
System.out.println("被修改的元素是：" + str2); // one
System.out.println("修改后集合中的元素有：" + lt1); // [one, two, three, four]
System.out.println("------------------------------------------");
// 7.使用remove方法将集合中的所有元素删除
//for (int i = 0; i < lt1.size(); /*i++*/) {
/* for (int i = lt1.size()-1; i >= 0; i--) {
//System.out.println("被删除的元素是：" + lt1.remove(i)); // one two three four 删除元素后，后面的元素补位
//System.out.println("被删除的元素是：" + lt1.remove(0));
System.out.println("被删除的元素是：" + lt1.remove(i));
}
System.out.println("最终集合中的元素有：" + lt1); // [啥也没有]*/
System.out.println("------------------------------------------");
// 8.获取当前集合中的子集合，也就是将集合中的一部分内容获取出来，子集合和当前集合共用同一块内存空间
// 表示获取当前集合lt1中下标从1开始到3之间的元素，包含1但不包含3
List lt2 = lt1.subList(1, 3);
System.out.println("lt2 = " + lt2); // [two, three]
// 删除lt2中元素的数值
str2 = (String) lt2.remove(0);
System.out.println("被删除的元素是：" + str2); // two
System.out.println("删除后lt2 = " + lt2); // [three]
System.out.println("删除后lt1 = " + lt1); // [one, three, four]
}
}
| 方法声明 | 功能介绍 |
|---|---|
| boolean offer(E e) | 将一个对象添加至队尾，若添加成功则返回true |
| E poll() | 从队首删除并返回一个元素 |
| E peek() | 返回队首的元素（但并不删除） |
案例题目
准备一个Stack集合，将数据11、22、33、44、55依次入栈并打印，然后查看栈顶元素并打印，然后将栈中所有数据依次出栈并打印。再准备一个Stack对象，将数据从第一个栈中取出来放入第二个栈中，然后再从第二个栈中取出并打印。
4.6 Queue集合
4.6.1 基本概念
java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系。
该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO)。
该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。
4.6.2 常用的方法
案例题目
准备一个Queue集合，将数据11、22、33、44、55依次入队并打印，然后查看队首元素并打印，
然后将队列中所有数据依次出队并打印。
5. 集合类库（下）
5.1 泛型机制
5.1.1 基本概念
通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。
为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错。泛型只在编译时期有效，在运行时期不区分是什么类型。
5.1.2 底层原理
泛型的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，用于给形式参数E进行初始化，从而使得集合中所有的E被实际参数替换，由于实际参数可以传递各种各样广泛的数据类型，因此得名为泛型。
如：
//其中i叫做形式参数，负责占位 其中E叫做形式参数，负责占位
//int i = 10; E = String;
//int i = 20; E = Integer;
public static void show(int i) { public interface List {
… …
} }
//其中10叫做实际参数，负责给形式参数初始化 //其中String叫做实际参数
show(10); List lt1 = …;
show(20); List lt2 = …;
5.1.3 自定义泛型接口
泛型接口和普通接口的区别就是后面添加了类型参数列表，可以有多个类型参数，如：<E, T, … >等。
5.1.4 自定义泛型类
泛型类和普通类的区别就是类名后面添加了类型参数列表，可以有多个类型参数，如：<E, T, … >等。
实例化泛型类时应该指定具体的数据类型，并且是引用数据类型而不是基本数据类型。
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型。
子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型。
/**
* 自定义泛型类Person，其中T相当于形式参数负责占位，具体数值由实参决定
* @param <T> 看做是一种名字为T的数据类型即可
*/
public class Person<T> {
private String name;
private int age;
private T gender;
public Person() {
}
public Person(String name, int age, T gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
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;
}
// 不是泛型方法，该方法不能使用static关键字修饰，因为该方法中的T需要在new对象时才能明确类型
public /*static*/ T getGender() {
return gender;
}
public void setGender(T gender) {
this.gender = gender;
}
// 自定义方法实现将参数指定数组中的所有元素打印出来
public static <T1> void printArray(T1[] arr) {
for (T1 tt: arr) {
System.out.println("tt = " + tt);
}
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender=" + gender +
'}';
}
}
public class PersonTest {
public static void main(String[] args) {
// 1.声明Person类型的引用指向Person类型的对象
Person p1 = new Person("zhangfei", 30, "男");
// 2.打印对象的特征
System.out.println(p1); // zhangfei 30 男
System.out.println("-----------------------------------");
// 3.在创建对象的同时指定数据类型，用于给T进行初始化
Person<String> p2 = new Person<>();
p2.setGender("女");
System.out.println(p2); // null 0 女
System.out.println("-----------------------------------");
// 4.使用Boolean类型作为性别的类型
Person<Boolean> p3 = new Person<>();
p3.setGender(true);
System.out.println(p3); // null 0 true
System.out.println("-----------------------------------");
// 5.调用泛型方法进行测试
Integer[] arr = {11, 22, 33, 44, 55};
Person.printArray(arr); // 11 22 33 44 55
}
}
//public class SubPerson extends Person { // 不保留泛型并且没有指定类型，此时Person类中的T默认为Object类型 擦除
//public class SubPerson extends Person<String> { // 不保留泛型但指定了泛型的类型，此时Person类中的T被指定为String类型
//public class SubPerson<T> extends Person<T> { // 保留父类的泛型 可以在构造对象时来指定T的类型
public class SubPerson<T, T1> extends Person<T> { // 保留父类的泛型，同时在子类中增加新的泛型
}
5.1.5 自定义泛型方法
泛型方法就是我们输入参数的时候，输入的是泛型参数，而不是具体的参数。我们在调用这个泛型方法的时需要对泛型参数进行实例化。
泛型方法的格式：
[访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) { 方法体; }
在静态方法中使用泛型参数的时候，需要我们把静态方法定义为泛型方法。
5.1.6 泛型在继承上的体现
如果B是A的一个子类或子接口，而G是具有泛型声明的类或接口，则G并不是G的子类型！
比如：String是Object的子类，但是List并不是List的子类。
5.1.7 通配符的使用
有时候我们希望传入的类型在一个指定的范围内，此时就可以使用泛型通配符了。
如：之前传入的类型要求为Integer类型，但是后来业务需要Integer的父类Number类也可以传
入。
泛型中有三种通配符形式：
1 <?> 无限制通配符：表示我们可以传入任意类型的参数。
2 <? extends E> 表示类型的上界是E，只能是E或者是E的子类。
3 <? super E> 表示类型的下界是E，只能是E或者是E的父类。
public class GenericTest {
public static void main(String[] args) {
// 1.声明两个List类型的集合进行测试
List<Animal> lt1 = new LinkedList<>();
List<Dog> lt2 = new LinkedList<>();
// 试图将lt2的数值赋值给lt1，也就是发生List<Dog>类型向List<Animal>类型的转换
//lt1 = lt2; Error: 类型之间不具备父子类关系
System.out.println("---------------------------------------------");
// 2.使用通配符作为泛型类型的公共父类
List<?> lt3 = new LinkedList<>();
lt3 = lt1; // 可以发生List<Animal>类型到List<?>类型的转换
lt3 = lt2; // 可以发生List<Dog>类型到List<?>类型的转换
// 向公共父类中添加元素和获取元素
//lt3.add(new Animal()); Error: 不能存放Animal类型的对象
//lt3.add(new Dog()); Error: 不能存放Dog类型的对象， 不支持元素的添加操作
Object o = lt3.get(0); // ok，支持元素的获取操作，全部当做Object类型来处理
System.out.println("---------------------------------------------");
// 3.使用有限制的通配符进行使用
List<? extends Animal> lt4 = new LinkedList<>();
// 不支持元素的添加操作
//lt4.add(new Animal());
//lt4.add(new Dog());
//lt4.add(new Object());
// 获取元素
Animal animal = lt4.get(0);
System.out.println("---------------------------------------------");
List<? super Animal> lt5 = new LinkedList<>();
lt5.add(new Animal());
lt5.add(new Dog());
//lt5.add(new Object()); Error: 超过了Animal类型的范围
Object object = lt5.get(0);
}
}
5.2 Set集合
5.2.1 基本概念
java.util.Set集合是Collection集合的子集合，与List集合平级。
该集合中元素没有先后放入次序，且不允许重复。
该集合的主要实现类是：HashSet类 和 TreeSet类以及LinkedHashSet类。
其中HashSet类的底层是采用哈希表进行数据管理的。
其中TreeSet类的底层是采用红黑树进行数据管理的。
二叉树的概念
有序二叉树的概念
其中LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元
素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
5.2.2 常用的方法
参考Collection集合中的方法即可
案例题目
准备一个Set集合指向HashSet对象，向该集合中添加元素"two"并打印，再向集合中添加元
素"one"并打印，再向集合中添加元素"three"并打印，再向集合中添加"one"并打印。
5.2.3 元素放入HashSet集合的原理
使用元素调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算出该元素在数组中的索引位置。
若该位置没有元素，则将该元素直接放入即可。
若该位置有元素，则使用新元素与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。
若新元素与已有元素的哈希值相同，则使用新元素调用equals方法与已有元素依次比较。
若相等则添加元素失败，否则将元素直接放入即可。
元素放入哈希表过程
思考：为什么要求重写equals方法后要重写hashCode方法呢？
解析：
当两个元素调用equals方法相等时证明这两个元素相同，重写hashCode方法后保证这两个元素得到的哈希码值相同，由同一个哈希算法生成的索引位置相同，此时只需要与该索引位置已有元素比较即可，从而提高效率并避免重复元素的出现。
5.2.4 TreeSet集合的概念
二叉树主要指每个节点最多只有两个子节点的树形结构。
满足以下3个特征的二叉树叫做有序二叉树。
a.左子树中的任意节点元素都小于根节点元素值；
b.右子树中的任意节点元素都大于根节点元素值；
c.左子树和右子树的内部也遵守上述规则；
由于TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使用新元素与集合中已有的元素依次比较来确定新元素的合理位置。
比较元素大小的规则有两种方式：
使用元素的自然排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口；
使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口；
自然排序的规则比较单一，而比较器的规则比较多元化，而且比较器优先于自然排序；
5.3 Map集合
5.3.1 基本概念
java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，其中类型参数如下：
K - 此映射所维护的键(Key)的类型，相当于目录。
V - 映射值(Value)的类型，相当于内容。
该集合中key是不允许重复的，而且一个key只能对应一个value。
该集合的主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、Properties类。
其中HashMap类的底层是采用哈希表进行数据管理的。
Set集合转换成Map集合原理
其中TreeMap类的底层是采用红黑树进行数据管理的。
其中LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
其中Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null作为key或者value的数值。
其中Properties类是Hashtable类的子类，该对象用于处理属性文件，key和value都是String类型的。
Map集合是面向查询优化的数据结构, 在大数据量情况下有着优良的查询性能。经常用于根据key检索value的业务场景。
5.3.2 常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| V put(K key, V value) | 将Key-Value对存入Map，若集合中已经包含该Key，则替换该Key所对 应的Value，返回值为该Key原来所对应的Value，若没有则返回null |
| V get(Object key) | 返回与参数Key所对应的Value对象，如果不存在则返回null |
| boolean containsKey(Object key); | 判断集合中是否包含指定的Key |
| boolean containsValue (Object value); | 判断集合中是否包含指定的Value |
| V remove(Object key) | 根据参数指定的key进行删除 |
| Set keySet() | 返回此映射中包含的键的Set视图 |
| Collection values() | 返回此映射中包含的值的Set视图 |
| Set<Map.Entry<K,V>> entrySet() | 返回此映射中包含的映射的Set视图 |
5.3.3 元素放入HashMap集合的原理
使用元素的key调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算在数组中的索引位置。
若该位置没有元素，则将该键值对直接放入即可。
若该位置有元素，则使用key与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入。
若key与已有元素的哈希值相同，则使用key调用equals方法与已有元素依次比较。
若相等则将对应的value修改，否则将键值对直接放入即可。
5.3.4 相关的常量
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量是16。
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子是0.75。
threshold：扩容的临界值，该数值为：容量*填充因子，也就是12。
TREEIFY_THRESHOLD：若Bucket中链表长度大于该默认值则转化为红黑树存储，该数值是8。
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量，该数值是64。
5.4 Collections类
5.4.1 基本概念
java.util.Collections类主要提供了对集合操作或者返回集合的静态方法。
5.4.2 常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) | 根据元素的自然顺序返回给定集 合的最大元素 |
| static T max(Collection<? extends T> coll, Comparator<? super T> comp) | 根据指定比较器引发的顺序返回 给定集合的最大元素 |
| static <T extends Object & Comparable<?super T>> T min(Collection<? extends T> coll) | 根据元素的自然顺序返回给定集 合的最小元素 |
| static T min(Collection<? extends T> coll, Comparator<? super T> comp) | 根据指定比较器引发的顺序返回 给定集合的最小元素 |
| static void copy(List<? super T> dest, List<? extends T> src) | 将一个列表中的所有元素复制到 另一个列表中 |
| 方法声明 | 功能介绍 |
|---|---|
| static void reverse(List<?> list) | 反转指定列表中元素的顺序 |
| static void shuffle(List<?> list) | 使用默认的随机源随机置换指定的列表 |
| static <T extends Comparable<? super T>> void sort(List list) | 根据其元素的自然顺序将指定列表按升 序排序 |
| static void sort(List list, Comparator<? super T> c) | 根据指定比较器指定的顺序对指定列表 进行排序 |
| static void swap(List<?> list, int i, int j) | 交换指定列表中指定位置的元素 |
扫一扫
338
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
