第一阶段模块三
常用类
常用包（熟悉）
包的名称和功能
1.java.lang包——该包是Java语言的核心，且该包中的所有内容由Java虚拟机自动导入
如：System类、String类
2.java.util包——该包是Java语言的工具包，里面提供了大量的工具类以及集合类
如：Scanner类、Random类、List集合、…
3.java.io包——该包是Java语言的输入输出包，提供了大量读写文件相关的类
如：FileInputStream类 、FileOutputStream类、…
4.java.net包——该包是Java预言中的网络包，提供了大量网络编程相关的类
如：ServerSocket类、Socket类、…
5.java.sql包——该包是Java语言循环的数据包，提供了大量操作数据库的类和接口
如：DriverManager类、Connection接口、…
Object类（重点）
概念
1.java.lang.Object类是Java语言中的根类，即任何一个类都是该类的直接或间接子类
2.若定义一个Java类时没有使用extends关键字声明其父类，则其父类为java.lang.Object类
构造方法
Object() ------ 无参构造方法
equals方法
boolean equals (Object obj)
1.用于判断调用对象是否与参数相等
2.该方法默认比较两个对象的地址值是否相等，与==运算符结果一致
3.若希望比较两个对象的内容，则需要重写该方法
4.若该方法重写后，则应该重写hashCode方法来保证结果的一致性
默认功能使用
public class Student {
private int id; // 学号
private String name; // 姓名
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
if(id > 0) {
this.id = id;
}else {
System.out.println("学号不合理！");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class StudentTest {
public static void main(String[] args) {
// 1.使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001,"张飞");
Student s2 = new Student(1002,"关羽");
//Student s2 = s1; // 表示s2和s1都指向了同一个对象
// 下面调用从Object类继的equals方法，该方法默认比较两个对象的地址值
boolean b1 = s1.equals(s2);
System.out.println("b1 = " + b1); // false
System.out.println(s1 == s2); // false
}
}
equals方法的重写实现
public class Student {
private int id; // 学号
private String name; // 姓名
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
if(id > 0) {
this.id = id;
}else {
System.out.println("学号不合理！");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比价两个对象的内容，也就是学号信息需要小红鞋该方法
*/
// Student this = s1;
// Object obj = s2;
@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;
return this.getId() == ts.getId();
}
// 否则类型不一致，没有可比性，则内容一定相同
return false;
}
}
public class StudentTest {
public static void main(String[] args) {
// 1.使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001,"张飞");
//Student s2 = new Student(1002,"关羽");
Student s2 = new Student(1001,"张飞");
//Student s2 = s1; // 表示s2和s1都指向了同一个对象
// 下面调用从Object类继的equals方法，该方法默认比较两个对象的地址值
// 当Student类中重写equals方法后，则调用重写以后的版本，比较内容
//boolean b1 = s1.equals(s2);
//Student s3 = null;
//boolean b1 = s1.equals(s3);
Student s3 = s1;
boolean b1 = s1.equals(s3);
System.out.println("b1 = " + b1); // false
System.out.println(s1 == s2); // false
}
}
hashCode方法
int hashCode()
1.用于获取调用对象的哈希码值（内存地址编号）
2.若两个对象调用equals方法相等，则各自调用该方法的结果必须相同
3.若两个对象调用equals方法不相等，则各自调用该方法的结果应该不相同
4.为了使得该方法与equals方法保持一致，需要重写该方法
public class Student {
private int id; // 学号
private String name; // 姓名
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
if(id > 0) {
this.id = id;
}else {
System.out.println("学号不合理！");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比价两个对象的内容，也就是学号信息需要小红鞋该方法
*/
// Student this = s1;
// Object obj = s2;
@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;
return this.getId() == ts.getId();
}
// 否则类型不一致，没有可比性，则内容一定相同
return false;
}
/**
* 为了使得giant方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定需要重写该方法
*/
@Override
public int hashCode() {
//return getId(); // 不在代表内存地址的编号了
final int type = 12;
return type*12 + getId();
}
}
public class StudentTest {
public static void main(String[] args) {
// 1.使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001,"张飞");
//Student s2 = new Student(1002,"关羽");
Student s2 = new Student(1001,"张飞");
//Student s2 = s1; // 表示s2和s1都指向了同一个对象
// 下面调用从Object类继的equals方法，该方法默认比较两个对象的地址值
// 当Student类中重写equals方法后，则调用重写以后的版本，比较内容
//boolean b1 = s1.equals(s2);
//Student s3 = null;
//boolean b1 = s1.equals(s3);
//Student s3 = s1;
boolean b1 = s1.equals(s2);
System.out.println("b1 = " + b1); // false true
System.out.println(s1 == s2); // 比较地址 false
System.out.println("----------------------------------------------");
// 下面调用从Object中继承下来的hashCode方法，获取调用对象的哈希码值（内存地址编号）
int ia = s1.hashCode();
int ib = s2.hashCode();
System.out.println("ia = " + ia);
System.out.println("ib = " + ib);
}
}
toString方法
String toString()
1.用于获取调用对象的字符串形式
2.该方法默认返回的字符串为：包名.类名@哈希码值的十六进制
3.为了返回更有意义的数据，需要重写该方法
4.使用print或println打印引用或字符串拼接引用都会自动调用该方法
public class Student {
private int id; // 学号
private String name; // 姓名
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
if(id > 0) {
this.id = id;
}else {
System.out.println("学号不合理！");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比价两个对象的内容，也就是学号信息需要小红鞋该方法
*/
// Student this = s1;
// Object obj = s2;
@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;
return this.getId() == ts.getId();
}
// 否则类型不一致，没有可比性，则内容一定相同
return false;
}
/**
* 为了使得giant方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定需要重写该方法
*/
@Override
public int hashCode() {
//return getId(); // 不在代表内存地址的编号了
final int type = 12;
return type*12 + getId();
}
/**
* 为了返回更有意义的字符串数据，需要重写该方法
*/
@Override
public String toString() {
return "Student[id = " + getId() + ",name = " + getName() + "]";
}
}
public class StudentTest {
public static void main(String[] args) {
// 1.使用有参方式构造Student类型的两个对象并判断是否相等
Student s1 = new Student(1001,"张飞");
//Student s2 = new Student(1002,"关羽");
Student s2 = new Student(1001,"张飞");
//Student s2 = s1; // 表示s2和s1都指向了同一个对象
// 下面调用从Object类继的equals方法，该方法默认比较两个对象的地址值
// 当Student类中重写equals方法后，则调用重写以后的版本，比较内容
//boolean b1 = s1.equals(s2);
//Student s3 = null;
//boolean b1 = s1.equals(s3);
//Student s3 = s1;
boolean b1 = s1.equals(s2);
System.out.println("b1 = " + b1); // false true
System.out.println(s1 == s2); // 比较地址 false
System.out.println("----------------------------------------------");
// 下面调用从Object中继承下来的hashCode方法，获取调用对象的哈希码值（内存地址编号）
// 当Student类中重写hashCode方法后，则调用重写以后的版本
int ia = s1.hashCode();
int ib = s2.hashCode();
System.out.println("ia = " + ia);
System.out.println("ib = " + ib);
System.out.println("----------------------------------------------");
// 下面调用从Object中继承的toString方法，获取调用对象的字符串形式：包名.类名@哈希码值的十六进制
// 当Student类中重写toString方法后，则调用重写以后的版本
String str1 = s1.toString();
System.out.println("str1 = " + str1); // com.wei.Part3.Task01.Student@479
System.out.println(s1); // 当发音一个引用变量时会自动调用toString方法
String str2 = "hello" + s1;
System.out.println("str2 = " + str2); // 使用print或println打印引用或字符串拼接引用都会自动调用该方法
}
}
姓名作为基准重写方法
public class Student {
private int id; // 学号
private String name; // 姓名
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
if(id > 0) {
this.id = id;
}else {
System.out.println("学号不合理！");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
/**
* 为了比价两个对象的内容，也就是学号信息需要重写该方法
*/
// Student this = s1;
// Object obj = s2;
@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;
}
/**
* 为了使得giant方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定需要重写该方法
*/
@Override
public int hashCode() {
//return getId(); // 不在代表内存地址的编号了
final int type = 12;
//return type*31 + getId();
return type*31 + getName().hashCode();
}
/**
* 为了返回更有意义的字符串数据，需要重写该方法
*/
@Override
public String toString() {
return "Student[id = " + getId() + ",name = " + getName() + "]";
}
}
Class<?> getClass()
用于返回调用对象执行时的Class实例，反射机制使用
public class Student {
private int id; // 学号
private String name; // 姓名
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public int getId() {
return id;
}
public void setId(int id) {
if(id > 0) {
this.id = id;
}else {
System.out.println("学号不合理！");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return id == student.id &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
/* @Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (id != student.id) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = id;
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
}*/
/*
*//**
* 为了比价两个对象的内容，也就是学号信息需要重写该方法
*//*
// Student this = s1;
// Object obj = s2;
@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;
}
*//**
* 为了使得giant方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定需要重写该方法
*//*
@Override
public int hashCode() {
//return getId(); // 不在代表内存地址的编号了
final int type = 12;
//return type*31 + getId();
return type*31 + getName().hashCode();
}
*//**
* 为了返回更有意义的字符串数据，需要重写该方法
*//*
@Override
public String toString() {
return "Student[id = " + getId() + ",name = " + getName() + "]";
}*/
}
包装类(熟悉)
概念
通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类
分类
| 包装类 | 对应的基本数据类型 |
|---|---|
| Byte | byte |
| Short | short |
| Integer | int |
| Long | long |
| Float | float |
| Double | double |
| Boolean | boolean |
| Character | char |
Integer类
基本概念
Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类型之间的转换等方法
常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
| public static int MAX_VALUE | 表示int类型可以描述的最大值，即2^31-1 |
| public static int MIN_VALUE | 表示int类型可以描述的最小值，即-2^31-1 |
| public static int SIZE | 表示int类型采用二进制补码形式的位数 |
| public static int BYTES | 表示int类型所占的字节个数 |
| public static int ClassTYPE | 表示int类型的Class实例 |
public class IntegerTest {
public static void main(String[] args) {
// 1.打印Integer类中的常量数值
System.out.println("最大值是：" + Integer.MAX_VALUE); // 2^31-1
System.out.println("最小值是：" + Integer.MIN_VALUE); // -2^31
System.out.println("所表示二进制的位数是：" + Integer.SIZE); // 32
System.out.println("所占字节个数是：" + Integer.BYTES); // 4
System.out.println("对应int类型的Class实例是：" + Integer.TYPE); // int
System.out.println("-------------------------------------------------");
// 2.使用构造方法来构造Integer类型的对象并打印
//Integer it1 = new Integer(123);
//System.out.println("it1 = " + it1); // 自动调用toString方法 123
//Integer it2 = new Integer("456");
//System.out.println("it2 = " + it2); // 456
// 上述方法已过时，建议使用valueOf()方法取代之,相当于从int类型到Integer类型的转换
Integer it3 = Integer.valueOf(123);
System.out.println("it3 = " + it3); // 123
// 相当于从String类型到Integer类型的转换
Integer it4 = Integer.valueOf("456");
System.out.println("i4 = " + it4); // 456 自动调用toString方法得到的是String类型
// 获取调用对象中的整数数值,相当于从Integer类型到int类型的转换
int ia = it4.intValue();
System.out.println("获取到的整数数据是：" + ia); // 456 得到的是int类型
}
}
常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| 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） | 获取参数指定整数的八进制字符串形式 |
// 5.实现静态方法的调用
int ic = Integer.parseInt("200");
//int ic = Integer.parseInt("200a"); // 编译OK，运行发生NumberFormatException数字格式异常，因为有字母
System.out.println("字符串转换为整数的结果是：" + ic); // 200
System.out.println("根据参数指定的整数获取对应十进制字符串是：" + Integer.toString(200)); // 200
System.out.println("根据参数指定的整数获取对应二进制字符串是：" + Integer.toBinaryString(200)); // 11001000
System.out.println("根据参数指定的整数获取对应十六进制字符串是：" + Integer.toHexString(200)); // c8
System.out.println("根据参数指定的整数获取对应八进制字符串是：" + Integer.toOctalString(200)); // 310
Integer类的装箱拆箱机制
在Java5之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。
从Java5开始增加了自动拆箱和自动装箱的功能。
// 3.从Java5开始增加了自动装箱和拆箱机制
Integer it5 = 100; // 直接通过赋值运算符实现自动装箱
int ib = it5; // 直接通过赋值运算符实现自动拆箱
自动装箱池
在Integer类的内部提供了自动装箱池技术，将-128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。
// 4，装箱拆箱笔试考点
Integer it6 = 127; //128;
Integer it7 = 127; //128;
Integer it8 = new Integer(127); //new Integer(128);
Integer it9 = new Integer("127"); //new Integer(128);
System.out.println(it6 == it7); // 比较地址 false true 地址一样
System.out.println(it6.equals(it7)); // 比较内容 true
System.out.println(it8 == it9); // 比较地址 false
System.out.println(it8.equals(it9)); // 比较内容 true
Double类
概念
Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double类型的包装并提供double类型到String类之间的转换等方法。
常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
| public static final int SIZE | 表示double类型的二进制位数 |
| public static final int BYTES | 表示double类型的字节个数 |
| public static final Class TYPE | 表示double类型的Class实例 |
常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| 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() | 判断调用对象的数值是否为非数字 |
Number类是个抽象类，是上述类的父类来描述所有类共有的成员。
public class DoubleTest {
public static void main(String[] args) {
// 1.Java5之前装箱拆箱的实现,实现了double类型到Double类型的转换，装箱
Double db1 = Double.valueOf(3.14);
System.out.println("db1 = " + db1); // 3.14
// 实现了从Double类型到double类型的转换，拆箱
double d1 = db1.doubleValue();
System.out.println("d1 = " + d1); // 3.14
System.out.println("--------------------------------------------");
// 2.从Java5之后开始实现自动装箱拆箱
Double db2 = 3.14;
double d2 = db2;
System.out.println("--------------------------------------------");
// 3.实现静态方法和成员方法的调用
double d3 = Double.parseDouble("13.14");
System.out.println("d3 = " + d3); // 13.14
System.out.println("db2对象的判断结果是：" + db2.isNaN()); // false 不是非数字
Double db3 = Double.valueOf(0/0.0);
System.out.println("db3对象的判断结果是：" + db3.isNaN()); // true 是非数字
}
}
Boolean类
概念
Boolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对boolean类型的包装并提供boolean类型到String类之间的转换等方法。
常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
| public static final Boolean FALSE | 对应基值为false的对象 |
| public static final Boolean TRUE | 对应基值为true的对象 |
| public static final Class TYPE | 表示boolean类型的Class实例 |
常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| 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类型并返回 |
public class BooleanTest {
public static void main(String[] args) {
// 1.在Java5之前采用方法进行装箱拆箱
// 相当于凶boolean到Boolean的转换，装箱
Boolean bo1 = Boolean.valueOf(true);
System.out.println("bo1 = " + bo1); // true
//
boolean b1 = bo1.booleanValue(); // 拆箱
System.out.println("b1 = " + b1); // true
System.out.println("--------------------------");
// 2.从Java5开始支持自动装箱拆箱
Boolean bo2 = false;
boolean b2 = bo2;
System.out.println("b2 = " + b2);
System.out.println("--------------------------");
// 3.从String类型到boolean类型的转换
//boolean b3 = Boolean.parseBoolean("112"); //false
// 该方法的执行原理是：只要参数值不为true或者TRUE时，则结果就是false
boolean b3 = Boolean.parseBoolean("TRUE");
System.out.println("b3 = " + b3); // true
}
}
Character类
概念
Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型的包装并提供字符类别的判断和转换等方法。
常用的常量
| 常量类型和名称 | 功能介绍 |
|---|---|
| public static final int SIZE | 表示char类型的二进制位数 |
| public static final int BYTES | 表示char类型的字节个数 |
| public static final Class TYPE | 表示char类型的Class实例 |
常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| 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) | 将参数指定的字符转换为小写字符 |
public class CharacterTest {
public static void main(String[] args) {
// 1.在Java5之前调用方法实现装箱拆箱\
// 相当于从char类型到Character类型的转换，装箱
Character ca1 = Character.valueOf('a');
System.out.println("ca1 = " + ca1); // a
// 相当于从Character类型到char类型的转换，拆箱
char c1 = ca1.charValue();
System.out.println("c1 = " + c1); // a
System.out.println("---------------------------");
// 2.从Java5开始支持自动装箱拆箱
Character ca2 = 'b';
char c2 = ca2;
System.out.println("c2 = " + c2); // b
System.out.println("---------------------------");
// 3.实现字符类型的判断以及转换
System.out.println(Character.isUpperCase(c2)); // 判断是否为大写字母 false
System.out.println(Character.isLowerCase(c2)); // 判断是否为小写字母 true
System.out.println(Character.isDigit(c2)); // 判断是否为数字字符 false
System.out.println("转换为大写字符是：" + Character.toUpperCase(c2)); // B
System.out.println("转换为小写字符是：" + Character.toLowerCase(c2)); // b
}
}
包装类使用总结
1.基本数据类型转换为对应包装类的方式
调用包装类的构造方法或静态方法即可
2.获取包装类对象中基本数据类型变量数值的方式
调用包装类中的xxxValue方法即可
3.字符串转换为基本数据类型的方式
调用包装类中的parseXxx方法即可
数学处理类（熟悉）
Math类
概念
Math类主要用于提供执行数学运算的方法，如：对数，平方根。
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| 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的随机数 |
public class MathTest {
public static void main(String[] args) {
System.out.println("获取两个整数中最大值的结果是：" + Math.max(10,20)); // 20
System.out.println("获取两个整数中最小值的结果是：" + Math.max(10,20)); // 10
System.out.println("获取次方的结果是：" + Math.pow(2,3)); // 2^3 = 8.0 体现double类型
System.out.println("获取绝对值的结果是：" + Math.abs(-5)); // 5
System.out.println("进行四舍五入的结果是：" + Math.round(3.14)); // 3
System.out.println("该整数的平方根是：" + Math.sqrt(16)); // 4
System.out.println("生成的随机数是：" + Math.random()); // 随机数
}
}
BigDecimal类
概念
由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型加以描述
常用的方法
| 方法声明 | 功能介绍 |
|---|---|
| BigDecimal(String val) | 根据参数指定的字符串来构造对象 |
| BigDecimal add(BigDecimal augend) | 用于实现加法运算 |
| BigDecimal subtract(BigDecimal subtrahend) | 用于实现减法运算 |
| BigDecimal multiply(BigDecimal multiplicand) | 用于实现乘法运算 |
| BigDecimal divide(BigDecimal divisor) | 用于实现除法运算 |
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalTest {
public static void main(String[] args) {
// 1.构造BigDeciaml类型的两个对象
BigDecimal bd1 = new BigDecimal("5.2");
BigDecimal bd2 = new BigDecimal("1.3");
// 2.使用构造完毕的对象实现加减乘除运算
System.out.println("实现加法运算的结果是：" + bd1.add(bd2)); // 6.5
System.out.println("实现减法运算的结果是：" + bd1.subtract(bd2)); // 3.9
System.out.println("实现乘法运算的结果是：" + bd1.multiply(bd2)); // 6.76
System.out.println("实现除法运算的结果是：" + bd1.divide(bd2)); // 4
System.out.println("----------------------------------------------------");
// 3.实现精确运算
System.out.println(0.1 + 0.2); // 0.30000000000004
BigDecimal bd3 = new BigDecimal("0.1");
BigDecimal bd4 = new BigDecimal("0.2");
System.out.println("精确运算的结果是：" + bd3.add(bd4)); // 0.3
System.out.println("----------------------------------------------------");
// 4.注意事项
BigDecimal bd5 = new BigDecimal("2");
BigDecimal bd6 = new BigDecimal("0.3");
System.out.println("乘法运算的结果是：" + bd5.divide(bd6, RoundingMode.HALF_UP)); // 7
}
}
BigInteger类
概念
若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| 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) | 用于实现取商和余数的运算 |
public class BigIntegerTest {
public static void main(String[] args) {
// 1.构造两个BIgInteger类型的对象并指定初始值
BigInteger bi1 = new BigInteger("20");
BigInteger bi2 = new BigInteger("8");
// 2.实现加减乘除取余操作并打印
System.out.println("实现加法运算的结果：" + bi1.add(bi2)); // 28
System.out.println("实现减法运算的结果：" + bi1.subtract(bi2)); // 12
System.out.println("实现乘法运算的结果：" + bi1.multiply(bi2)); // 160
System.out.println("实现除法运算的结果：" + bi1.divide(bi2)); // 2
System.out.println("实现取余运算的结果：" + bi1.remainder(bi2)); // 4
System.out.println("---------------------------------------------------");
// 3.一次性得到商和余数
BigInteger[] arr = bi1.divideAndRemainder(bi2);
for (int i = 0; i < arr.length; i++) {
System.out.println("下标为" + i + "的元素是：" + arr[i]); // 2 4
}
}
}
String类
String类的概念（重点）
1.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如：“abc”
2.该类由final关键字修饰，不能被继承
3.从JDK1.9开始该类的底层不使用char[]来存储数据，而是改成byte[]加上编码标记，从而节约空间
4.该类描述的字符串内容是个常量不可更改，可以被共享使用
如：
String str1 = “abc”; - 其中"abc"这个字符串是个常量不可改变。
str1 = “123”; - 将“123”字符串的地址赋值给变量str1。
改变str1的指向并没有改变指向的内容
常量池（原理）
由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对
象，从而提高了性能
public class StringPoolTest {
public static void main(String[] args) {
// 1.验证常量池的存在
// 到目前为止，只有String这特殊类处理new的方式外还可以直接字符串赋值（包装类除外）
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2); // 比较地址 true
}
}
常用构造方法（练熟、记住）
| 方法声明 | 功能介绍 |
|---|---|
| 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) | 根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本 |
public class StringConstructorTest {
public static void main(String[] args) {
// 1.使用无参方式构造对象并打印
String str1 = new String();
// "" 表示空字符串对象，有对象只是里面没有内容
// null 表示空，连对象都没有
System.out.println("str1 = " + str1); // str1 = "" 自动调用toString方法
System.out.println("--------------------------------------------");
// 2.使用参数指定的byte数组来构造对象并打印
// 'a' - 97
byte[] bArr = {97,98,99,100,101};
// 使用字节数组中的一部分内容来构建对象,表示使用数组bArr中从下标1开始的3个字节构造字符串对象
// 构造字符串的思路：就是先将每个整数翻译成对应的字符，再将所有的字符串起来
// 98 - 'b' 99 - 'c' 100 - 'd'
String str2 = new String(bArr,1,3);
System.out.println("str2 = " + str2); // bcd
// 使用整个字节数组来构造字符串对象
String str3 = new String(bArr);
System.out.println("str3 = " + str3); // abcde
System.out.println("--------------------------------------------");
// 3.使用字符数组来构造字符串对象
// 思路：直接将字符串起来
char[] cArr = {'h', 'e', 'l', 'l', 'o'};
String str4 = new String(cArr,2,2);
System.out.println("str4 = " + str4); // ll
// 使用整个字符数组来构造字符串对象
String str5 = new String(cArr);
System.out.println("str5 = " + str5); // hello
System.out.println("--------------------------------------------");
// 4.使用字符串来构造字符串对象
String str6 = new String("world");
System.out.println("str6 = " +str6); // world
}
}
String类笔试考点
public class StringExamTest {
public static void main(String[] args) {
// 1.请问下面的代码会创建几个对象？分别存放在什么地方？
//String str1 = "hello"; // 1个对象 存放在常量池中
//String str1 = new String("hello"); // 2个对象 1个在常量池中，1个在堆区
// 2.常量池和堆区对象的比较
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
System.out.println("-------------------------------------");
// 3.常量有优化机制，变量没有
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
}
}
常用的成员方法（练熟、记住）
String类型和数组之间的转换
| 方法声明 | 功能介绍 |
|---|---|
| String toString() | 返回字符串本身 |
| byte[] getBytes() | 将当前字符串内容转换为byte数组并返回 |
| char[] toCharArray() | 用于将当前字符串内容转换为char数组并返回 |
public class StringByteCharTest {
public static void main(String[] args) {
// 1.创建String类型的对象并打印
String str1 = new String("world");
System.out.println("str1 = " + str1); // world
System.out.println("-----------------------------------");
// 2.实现将String类型转换为byte数组类型
// 思路：先将字符串拆分为字符，然后将每个字符转换为byte类型，也就是获取所有字符的ASCII
byte[] bArr = str1.getBytes();
for (int i = 0; i < bArr.length; i++) {
System.out.println("下标为" + i + "的元素是：" + bArr[i]);
}
// 将byte数组转回String类型并打印
String str2 = new String(bArr);
System.out.println("转回字符串为：" + str2); // world
System.out.println("-----------------------------------");
// 3.实现将String类型转换为char类型数组并打印
// 思路：将字符串拆分为字符并保存到数组中
char[] cArr = str1.toCharArray();
for (int i = 0; i < cArr.length; i++) {
System.out.println("下标为" + i + "的字符是：" + cArr[i]);
}
// 将char数组转回到String类型并打印
String str3 = new String(cArr);
System.out.println("转回的字符串为：" + str3); // world
}
}
String类中字符的获取和使用
| 方法声明 | 功能介绍 |
|---|---|
| char charAt(int index) | 方法charAt用于返回字符串指定位置的字符 |
| int length() | 返回字符串字符序列的长度 |
| boolean isEmpty() | 判断字符串是否为空 |
public class StringCharTest {
public static void main(String[] args) {
// 1.构造String类型对象并打印
String str1 = new String("hello");
System.out.println("str1 = " + str1); // hello
// 获取字符串的长度和每个字符并打印
System.out.println("字符串的长度是：" + str1.length()); // 5
System.out.println("下标为0的字符是：" + str1.charAt(0)); // h
System.out.println("下标为1的字符是：" + str1.charAt(1)); // e
System.out.println("下标为2的字符是：" + str1.charAt(2)); // l
System.out.println("下标为3的字符是：" + str1.charAt(3)); // l
System.out.println("下标为4的字符是：" + str1.charAt(4)); // o
//System.out.println("下标为5的字符是：" + str1.charAt(5)); // StringIndexOutOfBoundsException 字符串下标越界异常
System.out.println("-------------------------------------------");
// 3.使用for循环获取所有字符
for (int i = 0; i < str1.length(); i++) {
System.out.println("下标为" + i + "的字符是：" + str1.charAt(i)); // h e l l o
}
System.out.println("-------------------------------------------");
// 4.判断字符串是否为空
System.out.println(0 == str1.length()? "字符串为空" : "字符串不为空"); // 不为空
System.out.println(str1.isEmpty()? "字符串为空" : "字符串不为空"); // 不为空
System.out.println("-------------------------------------------");
// 5.笔试的考点
// 使用两种方式实现字符串“12345”转换为整数12345并打印
String str2 = new String("12345");
// 方式1：调用Integer类型中的parseInt()方法即可
int ia = Integer.parseInt(str2);
System.out.println("转换出来的整数是：" + ia); // 12345
// 方式2：利用ASCII来实现类型转换并打印 0-
// '1' - 48 => '2' - '0' => 2 ...
int ib = 0;
for (int i = 0; i < str2.length(); i++) {
ib = ib*10 + (str2.charAt(i) - '0');
}
System.out.println("转换出来的结果是：" + ib); // 12345
System.out.println("-------------------------------------------");
// 如何实现整数到字符串的转换
//String str3 = String.valueOf(ib);
String str3 = "" + ib; // 推荐使用
System.out.println("str3 = " + str3); // 12345
}
}
String类对象实现会回文的判断
案例：
判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文就是指一个字符序列无论从左向右读还是从右向左读都是相同的句子。
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 + "是回文！");
}
}
String类实现字符串之间大小的比较
| 方法声明 | 功能介绍 |
|---|---|
| int compareTo(String anotherString) | 用于比较调用对象和参数对象的大小关系 |
| int compareToIgnoreCase(String str) | 不考虑大小写，也就是’a’和’A’是相等关系 |
public class StringCompareTest {
public static void main(String[] args) {
// 1.构造S他日光你类型对象并打印
String str1 = new String("hello");
System.out.println("str1 = " + str1); // hello
// 2.使用构造好的对象与其他字符串对象之间比较大小并打印
System.out.println(str1.compareTo("world")); // 'h' - 'w' => 104 - 119 = -15
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类实现各种方法的使用
| 方法声明 | 功能介绍 |
|---|---|
| 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) | 判断字符串是否以参数字符串结尾 |
public class StringManyMethodTest {
public static void main(String[] args) {
// 1.构造String类型对象并打印
String str1 = new String(" Let Me Give You Some Color To See See!");
System.out.println("str1 = " + str1); // Let Me Give You Some Color To See See!
// 2.实现各种成员方法的调用和测试
boolean b1 = str1.contains("some");
System.out.println("b1 = " + b1); // false 区分大小写
b1 = str1.contains("Some");
System.out.println("b1 = " + b1); // true
System.out.println("-----------------------------------------");
// 将所有字符串转换为大写 小写 以及去除两边的空白字符
String str2 = str1.toUpperCase();
System.out.println("str2 = " +str2); // LET ME GIVE YOU SOME COLOR TO SEE SEE!
System.out.println("str1 = " + str1); // Let Me Give You Some Color To See See! 常量
String str3 = str1.toLowerCase();
System.out.println("str3 = " + str3); // let me give you some color to see see!
System.out.println("str1 = " + str1); // Let Me Give You Some Color To See See!
String str4 = str1.trim();
System.out.println("str4 = " + str4); //Let Me Give You Some Color To See See!
System.out.println("-----------------------------------------");
// 判断字符串是否以...开头 以...结尾
b1 = str1.startsWith("Let");
System.out.println("b1 = " + b1); // false
b1 = str1.startsWith(" ");
System.out.println("b1 = " + b1); // true
// 从下标5开始是否以“Let”开头
b1 = str1.startsWith("Let",5);
System.out.println("b1 = " + b1); // true
b1 = str1.endsWith("See");
System.out.println("b1 = " + b1); // false
b1 = str1.endsWith("See!");
System.out.println("b1 = " + b1); // true
}
}
String类实现登陆功能模拟
| 方法声明 | 功能介绍 |
|---|---|
| boolean equals(Object anObject) | 用于比较字符串内容是否相等并返回 |
| int hashCode() | 获取调用对象的哈希码值 |
| boolean equalsIgnoreCase(String anotherString) | 用于比较字符串内容是否相等并返回，不考虑大小写，如：'A’和’a’是相等 |
案例：
/**
* @auther weiwei
* @date 2021/4/8 16:08
* @description 提示用户从键盘输入用户名和密码信息，
* 若输入”admin”和”123456”则提示“登录成功，欢迎使用”，
* 否则提示“用户名或密码错误，您还有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 name = sc.next();
String password = sc.next();
// 2.判断用户名和密码是否为“admin”和“123456”并给出提示
if("admin".equalsIgnoreCase(name) && "123456".equals(password)){
System.out.println("登陆成功，欢迎使用！");
break;
}//else{
if(1 == i){
System.out.println("账户已冻结，请联系客服人员！");
}else {
System.out.println("用户名或密码错误,您还有" + (i-1) + "次机会！");
}
//}
}
sc.close();
}
}
String类实现字符和字符串的查找(正向、反向)
| 方法声明 | 功能介绍 |
|---|---|
| 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指定的字符最后一次出现的下标 |
| nt lastIndexOf(int ch, int fromIndex) | 用于从fromIndex位置开始查找ch指定字符出现的下标 |
| int lastIndexOf(String str) | 返回str指定字符串最后一次出现的下标 |
| int lastIndexOf(String str, int fromIndex) | 用于从fromIndex位置开始反向搜索的第一次出现的下标 |
public class StringIndexTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("Good Good Study, Day Day Up!");
System.out.println("str1 = " + str1); // Good Good Study, Day Day Up!
// 2.实现字符串中指定字符和字符串的查找功能（正向查找）
int pos = str1.indexOf('g');
System.out.println("pos = " + pos); // -1 代表查找失败
pos = str1.indexOf('G');
System.out.println("pos = " + pos); // 0 该字符第一次出现的位置
// 表示从下标0开始查找字符'G'第一次出现的索引位置,包含0的位置
pos =str1.indexOf('G',0);
System.out.println("pos = " + pos); // 0 该字符第一次出现的位置
pos =str1.indexOf('G',1);
System.out.println("pos = " + pos); // 5 该字符第一次出现的位置
System.out.println("----------------------------------------------------");
// 查找字符串
pos = str1.indexOf("day");
System.out.println("pos = " + pos); // -1
pos = str1.indexOf("Day");
System.out.println("pos = " + pos); // 17 字符串中第一个字符的下标
pos = str1.indexOf("Day",17);
System.out.println("pos = " + pos); // 17 字符串中第一个字符的下标
pos = str1.indexOf("Day",18);
System.out.println("pos = " + pos); // 21 字符串中第一个字符的下标
System.out.println("------------------------------------------------------");
// 编写通用代码实现将字符串str1中所有“Day”出现的索引位置找到并打印
pos = str1.indexOf("Day");
while(-1 != pos){
System.out.println("pos = " + pos); // 17
pos = str1.indexOf("Day",pos+1);
}
System.out.println("------------------------------------------------------");
// 优化一下
pos = 0;
while((pos = str1.indexOf("Day",pos)) != -1){
System.out.println("pos = " + pos);
pos += "Day".length();
}
System.out.println("------------------------------------------------------");
// 3.实现字符和字符串内容的反向查找
pos = str1.lastIndexOf('G');
System.out.println("pos = " + pos); // 5
// 从下标5的位置开始泛型查找
pos = str1.lastIndexOf('G',5);
System.out.println("pos = " + pos); // 5
pos = str1.lastIndexOf('G',6);
System.out.println("pos = " + pos); // 5
pos = str1.lastIndexOf('G',4);
System.out.println("pos = " + pos); // 0
System.out.println("------------------------------------------------------");
pos = str1.lastIndexOf("Day");
System.out.println("pos = " + pos); // 21
pos = str1.lastIndexOf("Day",21);
System.out.println("pos = " + pos); // 21
pos = str1.lastIndexOf("Day",20);
System.out.println("pos = " + pos); // 17
pos = str1.lastIndexOf("Day",15);
System.out.println("pos = " + pos); // -1
}
}
String类中子字符串的获取
| 方法声明 | 功能介绍 |
|---|---|
| String substring(int beginIndex, int endIndex) | 返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串 |
| String substring(int beginIndex) | 返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串 |
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);
}
}
正则表达式
概念（了解）
本质就是一个“规则字符串”，可以用于对字符串数据的格式进行验证，以及匹配、查找、替换等操作。该字符串通常使用^运算符作为开头标志，使用$运算符作为结尾标志，当然也可以省略。
规则（了解）
| 正则表达式 | 说明 |
|---|---|
| [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? | 表示可以出现一次或一次与也没有，即0~1次 |
| X* | 表示可以出现零次或多次，即0~n次 |
| X+ | 表示可以出现一次或多次，即1~n次 |
| X{n} | 表示可以出现恰好n次 |
| X{n,} | 表示可以出现至少n次，即>=n次 |
| X{n,m} | 表示可以出现至少n次，但是不超过m次，即>=n并且<=m次 |
相关方法（熟悉）
| 方法名称 | 方法说明 |
|---|---|
| boolean matches(String regex) | 判断当前正在调用的字符串是否匹配参数指定的正则表达式规则 |
编程使用
public class StringRegTest {
public static void main(String[] args) {
// 1.定义描述规则的正则表达式字符串并使用变量记录
// 正则表达式只能对数据格式进行验证，无法对数据内容的正确性进行检查，内容的正确性检查需要后台查询数据库
// 描述银行卡密码的规则：由6位数字组成
//String reg = "^[0-9]{6}$";
//String reg = "[0-9]{6}";
//String reg = "\\d{6}";
// 正则表达式描述一下QQ号码的规则：要求是由非0开头的5~15位数字组成
//String reg = "[1-9]\\d{4,14}";
// 正则表达式描述一下手机号码的规则：要求是由1开头，第二位数是3、4、5、7、8中的一位，总共11位
//String reg = "1[34578]\\d{9}";
//描述身份证号码的规则：总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，最后一位可能数字也可能是X
String reg = "(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9|X])";
// 2.提示用户从键盘输入指定的内容并使用变量记录
Scanner sc = new Scanner(System.in);
while(true){
//System.out.println("请输入您的银行卡密码：");
//System.out.println("请输入您的QQ号码：");
//System.out.println("请输入您的手机号码：");
System.out.println("请输入您的身份证号码：");
String str = sc.next();
// 3.判断用户输入的字符串内容是否满足指定的规则并打印
if(str.matches(reg)){
//System.out.println("银行卡密码的格式正确！");
System.out.println("输入字符串的格式正确！");
break;
}else {
//System.out.println("银行卡的密码格式错误！");
System.out.println("输入字符串的格式错误！");
}
}
}
}
| 方法名称 | 方法说明 |
|---|---|
| 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 |
public class StringRegMethodTest {
public static void main(String[] args) {
// 1.准备一个字符串对象并打印
String str1 = "1001,zhangfei,30";
System.out.println("str1 = " + str1); // 1001,zhangfei,30
// 2.按照逗号对字符串内容进行切割
String[] sArr = str1.split(",");
for (int i = 0; i < sArr.length; i++) {
System.out.println("下标为" + i + "的字符串是: " + sArr[i]); // 1001 zhangfei 30
}
System.out.println("---------------------------------------");
// 3.准备一个字符串内容并进行替换
String str2 = "我的小名叫大帅哥";
// 将字符串中所有的字符'我'替换为'你'
String str3 = str2.replace('我','你');
System.out.println("str2 = " + str2); // 我的小名叫大帅哥
System.out.println("str3 = " + str3); // 你的小名叫大帅哥
// 将字符串中所有的字符'大'替换为'小'
String str4 = str3.replace('大','小');
System.out.println("str4 = " + str4); // 你的小名叫小帅哥
// 将字符串中所有的字符'小'替换为大'
String str5 = str4.replace('小','大');
System.out.println("str5 = " + str5); // 你的大名叫大帅哥
System.out.println("---------------------------------------");
// 4.准备一个字符串进行字符串内容的替换
String str6 = "123abc456def789ghi";
// 将第一个数字字符替换为“#”
String str7 = str6.replaceFirst("\\d+","#");
System.out.println("替换第一个字符串后的结果是： " + str7); // #abc456def789ghi
// 将所有字母字符串替换为"A"
String str8 = str7.replaceAll("[a-z]+","A");
System.out.println("str8 = " + str8); // #A456A789A
}
}
可变字符串类和日期类
可变字符串类（重点）
概念
1.由于String类描述的字符串内容是个常量不可改变，当需要在Java代码中描述大量类似的字符串时，只能单独申请和存储，此时会造成内存空间的浪费。
2.为了解决上述问题，可以使用java.lang.StringBuilder类和java.lang.StringBuffer类来描述字符序列可以改变的字符串，如：“ab”
3.StringBuffer类是从jdk1.0开始存在，线程安全，效率低
4.StringBuilder类是从jdk1.5开始存在，线程不安全，效率高
StringBuilder类常用构造方法
| 方法声明 | 功能介绍 |
|---|---|
| StringBuilder() | 使用无参方式构造对象，初始容量为16 |
| StringBuilder(int capacity) | 根据参数指定的容量来构造对象，容量为参数指定大小 |
| StringBuilder(String str) | 根据参数指定的字符串来构造对象，容量为：16+字符串长度 |
public class StringBuilderTest {
public static void main(String[] args) {
// 1.使用无参方式构造StrirgBuilder类型的对象并打印容量和长度
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()); // 21
System.out.println("长度是：" + sb3.length()); // 5
}
}
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会改变其值
public class StringBuilderTest {
public static void main(String[] args) {
// 1.使用无参方式构造StrirgBuilder类型的对象并打印容量和长度
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()); // 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("-------------------------------------");
// 向末位位置追加字符串内容"world"
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这个位置的字符修改为0
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、StringBuffer、StringBuilder之间效率谁高？排列如何？
// String < StringBuffer < StringBuilder
}
}
Java8之前的日期相关类（熟悉）
System类
概念
Java.lang.System类中提供了一些有用的类字段和方法
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| static long currentTimeMillis() | 返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差 |
public class SystemTest {
public static void main(String[] args) {
// 1.获取当前时间距离1970年1月1日0时0分0秒之间的毫秒数
long mesc = System.currentTimeMillis();
System.out.println("距离1970年1月1日0时0分0秒已经过去" + mesc + "毫秒了！");
// 通常用于测试某一段代码的执行效率
}
}
Date类
概念
java.util.Date类主要用于描述特定的瞬间，也就是年月日时分秒，可以精确到毫秒
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| Date() | 使用无参的方式构造对象，也就是当前系统时间 |
| Date(long date) | 根据参数指定毫秒数构造对象， 参数为距离1970年1月1日0时0分0秒的毫秒数 |
| long getTime() | 获取调用对象距离1970年1月1日0时0分0秒的毫秒数 |
| void setTime(long time) | 设置调用对象为距离基准时间time毫秒的时间点 |
public class DateTest {
public static void main(String[] args) {
// 1.使用无参方式构造Date对象并打印
Date d1 = new Date();
System.out.println("d1 = " + d1); // 获取当前系统时间
System.out.println("---------------------------------");
// 2.使用参数指定的毫秒数来构造Date类型的对象并打印 1秒 = 1000毫秒 时区：东八区
Date d2 = new Date(1000);
System.out.println("d2 = " + d2); // 1970 1 1 8 0 1
System.out.println("---------------------------------");
// 3.获取调用对象距离1970年1月1日0时0分0秒的毫秒数
long msec = d2.getTime();
System.out.println("获取到的毫秒数是：" + msec); // 1000
// 4.设置调用对象所表示的时间点为参数指定的毫秒数
d2.setTime(2000);
System.out.println("修改后的时间是：" + d2); // 1970 1 1 8 0 2
}
}
SimpleDateFormat类
概念
java.text.SimpleDateFormat类主要用于实现日期和文本之间的转换
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| SimpleDateFormat() | 使用无参方式构造对象 |
| SimpleDateFormat(String pattern) | 根据参数指定的模式来构造对象，模式主要有: y-年 M-月 d-日 H-时 m-分 s-秒 |
| final String format(Date date) | 用于将日期类型转换为文本类型 |
| Date parse(String source) | 用于将文本类型转换为日期类型 |
public class SimpleDateFormatTest {
public static void main(String[] args) throws ParseException {
// 1获取当前时间并打印
Date d1 = new Date();
System.out.println("d1 = " + d1);
// 2.构造SimpleDateFormat类型的对象并指定格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 3.实现日期类型向文本类型的转换并打印
// Alt+Enter 可以实现返回值的生成
String format = sdf.format(d1);
System.out.println("转换后的日期为：" + format);
// 4.实现文本类型向日期类型的转换并打印
Date parse = sdf.parse(format);
System.out.println("转回日期格式的结果为：" + parse);
}
}
Calendar类
概念
java.util.Calender类主要用于描述特定的瞬间，取代Date类中的过时方法实现全球化
该类是个抽象类，因此不能实例化对象，其具体子类针对不同国家的日历系统，其中应用最广泛的是GregorianCalendar（格里高利历），对应世界上绝大多数国家/地区使用的标准日历系统
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| 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) | 向指定字段增加数值 |
public class CalendarTest {
public static void main(String[] args) {
// 1.使用过时的方法按照指定的年月日时分秒来构造对象
Date d1 = new Date(2008-1900,8-1,8,20,8,8);
// 2.设置日期对象的格式并打印
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format = sdf.format(d1);
System.out.println("获取到的时间是：" + format); // 2008 8 8 20 8 8
System.out.println("---------------------------------------------------");
// 2.使用取代的方式按照指定的年月日时分秒来构造对象
// 2.1 获取Calendar类型的引用
// 考点：既然Calendar是抽象类不能创建对象，那么下面的方法为啥可以获取Calendar类型的引用？
// 解析：由源码可知，返回的并不是Calendar类型的对象，而是Calendar类型子类GregorianCalendar等的对象，形成了多态
// 多态使用场合之三：返回值类型形成多态
Calendar instance = Calendar.getInstance();
// 2.2 设置指定的年月日时分秒信息
instance.set(2008,8-1,8,20,8,8);
// 2.3 转换为Date类型的对象
Date d2 = instance.getTime();
String format1 = sdf.format(d2);
System.out.println("获取到的时间是：" + format1);
System.out.println("---------------------------------------------------");
// 3.向指定的字段设置以及增加指定的数值
instance.set(Calendar.YEAR,2021);
// 转换为Date类型并按照指定的格式打印
Date d3 = instance.getTime();
System.out.println("设置年份后的结果是：" + sdf.format(d3)); // 2021 8 8 20 8 8
instance.add(Calendar.MONTH,2);
Date d4 = instance.getTime();
System.out.println("增加月份后的结果是：" + sdf.format(d4)); // 2021 10 8 20 8 8
}
}
多态的使用场合
1.通过方法的参数传递形成多态
public static void draw(Shape s){
s.show();
}
draw(new Rect(1, 2, 3, 4));
2.在方法体中直接使用多态的语法格式
Account acc = new FixedAccount();
3.通过方法的返回值类型形成多态
Calender getInstance(){
return new GregorianCalendar(zone, aLocale);
}
Java8中的日期相关类(熟悉)
Java8日期类的由来
JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：
1.Date类中的年份是从1900开始的，而月份都从0开始
2.格式化只对Date类有用，对Calendar类则不能使用
3.线程不安全
Java8日期类
Java8通过发布新的Date-Time API来进一步加强对日期与时间的处理
java.time包：该包日期/时间API的基础包
java.time.chrono包：该包提供对不同日历系统的访问
java.time.format包：该包能够格式化和解析日期时间对象
java.time.temporal包：该包包含底层框架和扩展特性
java.time.zone包：该包支持不同时区以及相关规则的类
LocalDate类
概念
java.time.LocalDate类主要用于描述年-月-日格式的日期信息，该类不表示时间和时区信息
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| static LocalDate now() | 在默认时区中从系统时钟获取当前日期 |
LocalTime类
概念
java.time.LocalTime 类主要用于描述时间信息，可以描述时分秒以及纳秒
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| static LocalTime now() | 从默认时区的系统时间中获取当前时间 |
| static LocalTime now(ZoneId zone) | 获取指定时区的当前时间 |
LocalDateTime类
概念
java.time.LocalDateTime类主要用于描述ISO-8601日历系统中没有时区的日期时间，如2007-12-03T10:15:30
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| 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) | 减去参数指定的秒 |
public class LocalDateTimeTest {
public static void main(String[] args) {
// 1.获取当前日期信息(描述年-月-日格式)并打印
LocalDate now = LocalDate.now();
System.out.println("获取到的当前日期是：" + now);
// 2.获取当前时间信息(描述时分秒以及纳秒)并打印
LocalTime now1 = LocalTime.now();
System.out.println("获取到的当前时间是：" + now1);
// 3.获取当前日期时间信息(描述ISO-8601日历系统中没有时区的日期时间)并打印,使用最多
LocalDateTime now2 = LocalDateTime.now();
System.out.println("获取到的当前日期时间是：" + now2);
System.out.println("----------------------------------------------------------");
// 4.使用参数指定的年月日时分秒信息来获取对象并打印
// Ctrl+F12来查找指定的方法
LocalDateTime of = LocalDateTime.of(2008, 8, 8, 20, 8, 8);
System.out.println("指定的日期是：" + of); // 自动调用toString
System.out.println("获取到的年是：" + of.getYear()); // 2008
System.out.println("获取到的月是：" + of.getMonthValue()); // 8
System.out.println("获取到的日是：" + of.getDayOfMonth()); // 8
System.out.println("获取到的时是：" + of.getHour()); // 20
System.out.println("获取到的分是：" + of.getMinute()); // 8
System.out.println("获取到的秒是：" + of.getSecond()); // 8
System.out.println("----------------------------------------------------------");
// 5.实现特征的设置并打印
// 与String类相似，调用对象本身的数据内容不会改变，返回值相当于创建了一个新的对象，由此证明了不可变性
LocalDateTime localDateTime = of.withYear(2012);
System.out.println("localDateTime = " + localDateTime); // 2012-08-08T20:08:08
System.out.println("of = " + of); // 2008-08-08T20:08:08
LocalDateTime localDateTime1 = localDateTime.withMonth(12);
System.out.println("localDateTime1 = " + localDateTime1); // 2012-12-08T20:08:08
System.out.println("----------------------------------------------------------");
// 6.实现特征的增加并打印
LocalDateTime localDateTime2 = localDateTime1.plusDays(2);
System.out.println("localDateTime2 = " + localDateTime2); // 2012-12-10T20:08:08
System.out.println("localDateTime1 = " + localDateTime1); // 2012-12-08T20:08:08
LocalDateTime localDateTime3 = localDateTime2.plusHours(3);
System.out.println("localDateTime3 = " + localDateTime3); // 2012-12-10T23:08:08
System.out.println("----------------------------------------------------------");
// 7.实现特征的减少并打印
LocalDateTime localDateTime4 = localDateTime3.minusMinutes(1);
System.out.println("localDateTime4 = " + localDateTime4); // 2012-12-10T23:07:08
LocalDateTime localDateTime5 = localDateTime4.minusSeconds(3);
System.out.println("localDateTime5 = " + localDateTime5); // 2012-12-10T23:07:05
}
}
Instant类
概念
java.time.Instant类主要用于描述瞬间的时间点信息
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| 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秒的毫秒数 |
public class InstantTest {
public static void main(String[] args) {
// 1.使用instant类来获取当前系统时间 并不是当前系统的默认时区 本初子午线 差8小时
Instant now = Instant.now();
System.out.println("获取到的当前时间为：" + now);
// 2.加上时区所差的8个小时
OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));
System.out.println("偏移后的日期时间为：" + offsetDateTime);
System.out.println("-----------------------------------------------");
// 3.获取当前调用对象距离标准基准时间的毫秒数
long g1 = now.toEpochMilli();
System.out.println("获取到的毫秒差为：" + g1);
// 4.根据参数指定的毫秒数来构造对象
Instant instant = Instant.ofEpochMilli(g1);
System.out.println("根据参数指定的毫秒数构造出来的对象为：" + instant);
}
}
DateTimeFormatter类
概念
java.time.format.DateTimeFormatter类主要用于格式化和解析日期
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| static DateTimeFormatter ofPattern(String pattern) | 根据参数指定的模式来获取对象 |
| String format(TemporalAccessor temporal) | 将参数指定日期时间转换为字符串 |
| TemporalAccessor parse(CharSequence text) | 将参数指定字符串转换为日期时间 |
public class DateTimeFormatterTest {
public static void main(String[] args) {
// 1.获取当前系统的日期时间 并打印
LocalDateTime now = LocalDateTime.now();
System.out.println("now = " + now);
// 2.按照指定格式准备一个DateTimeFormatterTest类型的对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 3.实现日期时间向字符串类型的转换并打印
String str = dateTimeFormatter.format(now);
System.out.println("调整格式后的结果为：" + str);
// 4.实现字符串类型到日期时间类型的转换并打印
TemporalAccessor parse = dateTimeFormatter.parse(str);
System.out.println("转回去的结果是：" + parse);
}
}
集合类（上）
集合概述
集合由来
1.在Java程序中记录单个数据内容时，声明一个变量
2.在Java程序中记录多个类型相同的数据内容时，声明一个一维数组
3.在Java程序中记录多个类型不同的数据内容时，创建一个对象
4.在Java程序中记录多个类型相同的对象数据时，创建一个对象数组
5.在Java程序中记录多个类型不同的对象数据时，准备一个集合
集合的框架结构
Java中集合顶层框架是：java.util.Collection集合 和 java.util.Map集合
Collection集合中存取元素的基本单位是：单个元素
Map集合中存取元素的基本单位是：单对元素
Collection集合（重点）
概念
java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口，因此该接口里定义的方法既可用于操作List集合，也可用于操作Queue集合和Set集合
常用方法（练熟、记住）
| 方法声明 | 功能介绍 |
|---|---|
| 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("张飞",30));
System.out.println("b1 = " + b1); // true
// 打印集合中的所有元素时，本质上就是打印集合中的每个对象，也就是让每个对象调用对应类的toString方法
System.out.println("集合中的元素有：" + c1); // [one, 2, Person{name='张飞', 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); // [one, 2, Person{name='张飞', age=30}, [three, 4]]
System.out.println("b1 = " + b1);
System.out.println("c1 = " + c1); // // [one, 2, Person{name='张飞', age=30}, three, 4]
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("张飞",30));
System.out.println("b1 = " + b1); // true false
System.out.println("------------------------------------------");
// c1中的元素有：[one, 2, Person{name='张飞', 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
// 判断集合c1中是否拥有集合c2这个整体为单位的元素
b1 = c1.contains(c2);
System.out.println("b1 = " + b1); // false
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); // [4, five]
// 计算集合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.实现集合中单个元素的删除操作
System.out.println("c1 = " + c1); // [one, 2, Person{name='张飞', age=30}, three, 4]
// 删除参数指定的单个元素
b1 = c1.remove(1);
System.out.println("b1 = " + b1); // false
System.out.println("c1 = " + c1); // [one, 2, Person{name='张飞', age=30}, three, 4]
b1 = c1.remove("one");
System.out.println("b1 = " + b1); // true
System.out.println("c1 = " + c1); // [2, Person{name='张飞', age=30}, three, 4]
// remove方法的工作原理：Objects.equals(o, e)
b1 = c1.remove(new Person("张飞",30));
System.out.println("b1 = " + b1); // true
System.out.println("c1 = " + c1); // [2, three, 4]
System.out.println("------------------------------------------");
// 8.实现集合中所有元素的删除操作
System.out.println("c3 = " + c3); // [4, five]
// 从集合c1中删除集合c3中的所有元素
b1 = c1.removeAll(c3);
System.out.println("b1 = " + b1); // true
System.out.println("c1 = " + c1); // [2, three]
System.out.println("c3 = " + c3); // [4, five]
// 笔试考点
b1 = c1.remove(c3);
System.out.println("b1 = " + b1); // false
System.out.println("c1 = " + c1); // [2, three]
System.out.println("------------------------------------------");
// 9.实现集合中其他方法的测试 Ctrl+N 可以直接搜索并打开类的源码 使用Crtl+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]
// 判断是否相等
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]
}
}
Iterator接口（重点）
概念
java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中的所有元素
java.util.Collection接口继承Iterator接口，因此所有实现Collection接口的实现类都可以使用该迭代器对象
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| boolean hasNext() | 判断集合中是否有可以迭代/访问的元素 |
| E next() | 用于取出一个元素并指向下一个元素 |
| void remove() | 用于删除访问到的最后一个元素 |
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("张飞",30));
// 遍历方式一：自动调用toString方法 String类型的整体
System.out.println("c1 = " + c1); // [one, 2, Person{name='张飞', 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='张飞', 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(" ");
}
}
System.out.println("c1 = " + sb1); // [one, 2, Person{name='张飞', age=30}]
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='张飞', 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));
}
}
for each循环（重点）
概念
Java5推出了增强型for循环语句，可以应用数组和集合的遍历，是经典迭代的“简化版”
语法格式
for(元素类型 变量名 : 数组/集合名称) {
循环体;
}
执行流程
不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止
List集合（重中之重）
概念
1.java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序
2.该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类
3.ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删不方便
4.LinkedList类的底层是采用双向链表进行数据管理的，访问不方便，增删方便
5.可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别
6.Stack类的底层是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LIFO)
7.Vector类的底层是采用动态数组进行数据管理的，该类与ArrayList类相比线程安全，效率低，以后开发中基本不用
public class ListTest {
public static void main(String[] args) {
// 1.声明一个List接口类型的引用指向ArrayList类型的对象，形成了多态
// 由源码可知：当new对象时并没有申请数组的内存空间
List lt1 = new ArrayList();
// 2.向集合中添加元素并打印
lt1.add("one");
System.out.println("lt1 = " + lt1); // [one]
System.out.println("---------------------------------");
// 2.声明一个List类型的接口指向LinkedList类型的对象，形成多态
List lt2 = new LinkedList();
lt2.add("one");
System.out.println("lt2 = " + lt2); // [one]
}
}
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| 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, 3, two]
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);
// 若取出的元素是最后一个元素，则拼接元素值和]
if(lt1.size()-1 == i){
sb1.append(obj).append("]");
}else {
// 否则拼接元素和逗号以及空
sb1.append(obj).append(",").append(" ");
}
}
System.out.println("lt1 = " + sb1);
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);
System.out.println("被修改后集合中的元素有：" + lt1); // [onw, two, three, one]
String str2 = (String) lt1.set(3,"four");
System.out.println("被修改的元素是：" + str2);
System.out.println("被修改后集合中的元素有：" + lt1); // [onw, 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("被删除的元素是：" + lt2); // [two]
System.out.println("删除后lt2 = " + lt2); // [three]
System.out.println("删除后lt1 = " + lt1); // [one, three, four]
}
}
案例题目
1.准备一个Stack集合，将数据11、22、33、44、55依次入栈并打印，然后查看栈顶元素并打印
2.然后将栈中所有数据依次出栈并打印。再准备一个Stack对象，将数据从第一个栈中取出来放入第二个栈中，然后再从第二个栈中取出并打印。
public class StackTest {
public static void main(String[] args) {
// 1.准备一个Stack类型的对象并打印
Stack s1 = new Stack();
Stack s2 = new Stack();
System.out.println("s1 = " + s1); // [ ]
System.out.println("s2 = " + s2); // [ ]
System.out.println("---------------------------");
// 2.将数据11、22、33、44、55依次入栈并打印
for (int i = 1; i <= 5; i++) {
Object obj = s1.push(i * 11);
System.out.println("入栈的元素是：" + obj);
//System.out.println("栈中的元素有：" + s1); // 11 22 33 44 55
}
System.out.println("---------------------------");
// 3.查看栈顶元素并打印
Object obj2 = s1.peek();
System.out.println("获取到的栈顶元素是：" + obj2); // 55
System.out.println("---------------------------");
// 4.对栈中所有元素依次出栈并打印
int len = s1.size();
for (int i = 1; i <= len; i++) {
Object to = s1.pop();
//System.out.println("出栈的元素是：" + s1.pop()); // 55 44 33 22 11
s2.push(to);
}
System.out.println("---------------------------");
// 5.最终打印栈中的所有元素
//System.out.println("s1 = " + s1); // [ ]
System.out.println("---------------------------");
// 6
len = s2.size();
for (int i = 1; i <= len; i++) {
Object to = s2.pop();
System.out.println("出栈的元素是：" + to); // 11 22 33 44 55
}
}
}
Queue集合（重点）
概念
1.java.util.Queue集合是Collection集合的子集合，与List集合属于平级关系
2.该集合的主要用于描述具有先进先出特征的数据结构，叫做队列(first in first out FIFO)
3.该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| boolean offer(E e) | 将一个对象添加至队尾，若添加成功则返回true |
| E poll() | 从队首删除并返回一个元素 |
| E peek() | 返回队首的元素（但并不删除） |
public class QueueTest {
public static void main(String[] args) {
// 1.准备一个Queue集合并打印
Queue queue = new LinkedList();
System.out.println("队列中的元素有：" + queue); // [ ]
System.out.println("--------------------------------");
// 2.将数据11 22 33 44 55依次入队并打印
for (int i = 1; i <= 5; i++) {
boolean b1 = queue.offer(i*11);
//System.out.println("b1 = " + b1);
System.out.println("队中的元素有：" + queue); // 11 22 33 44 55
}
System.out.println("--------------------------------");
// 3.然后查看队首元素并打印
System.out.println("队首元素是：" + queue.peek()); // 11
System.out.println("--------------------------------");
// 4.将队列中所有数据依次出队并打印
int len = queue.size();
for (int i = 1; i <= len; i++) {
System.out.println("出队的元素是：" + queue.poll()); // 11 22 33 44 55
}
System.out.println("--------------------------------");
// 5.查看队列中最终元素
System.out.println("队列中的元素有：" + queue); // [ ]
}
}
集合类（下）
泛型机制（熟悉）
概念
1.通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常
2.为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错
3.泛型只在编译时期有效，在运行时期不区分是什么类型
public class ListGenericTest {
public static void main(String[] args) {
// 1.准备一个支持泛型机制的List集合，明确要求集合中的元素是String类型
List<String> lt1 = new LinkedList<String>();
// 2.向集合中添加匀速并打印
lt1.add("one");
System.out.println("lt1 = " + lt1); // [one]
// lt1.add(2); Error
// 3.获取集合中的元素并打印
String s = lt1.get(0);
System.out.println("获取到的元素是：" + s); // one
System.out.println("-------------------------------------------");
// 2.准备一个Integer类型的List集合
List<Integer> lt2 = new LinkedList<Integer>();
lt2.add(1);
lt2.add(2);
//lt2.add("3"); Error
System.out.println("lt2 = " + lt2);
Integer integer = lt2.get(0);
System.out.println("获取到的元素是：" + integer); // 1
System.out.println("-------------------------------------------");
// Java7开始的新特性：菱形特性 就是后面<>中的数据类型可以省略
List<Double> lt3 = new LinkedList<>();
// 笔试考点
// 师徒将lt1的数值赋值给lt3,也就是覆盖lt3中原来的数值，结果编译报错：集合中支持的类型不同
//lt3 = lt1; Error
}
}
底层原理
泛型的本质就是参数化类型，也就是让数据类型作为参数传递，其中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，用于给形式参数E进行初始化，从而使得集合中所有的E被实际参数替换，由于实际参数可以传递各种各样广泛的数据类型，因此得名为泛型。
自定义泛型接口
泛型接口和普通接口的区别就是后面添加了类型参数列表，可以有多个类型参数，如：<E, T, … >等
自定义泛型类
1.泛型类和普通类的区别就是类名后面添加了类型参数列表，可以有多个类型参数，如：<E, T, … >等
2.实例化泛型类时应该指定具体的数据类型，并且是引用数据类型而不是基本数据类型
3.父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型
4.子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型
/**
* @auther weiwei
* @date 2021/4/12 19:15
* @description 自定义泛型类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;
}
public T getGender() {
return gender;
}
public void setGender(T gender) {
this.gender = gender;
}
@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("张飞",30,"男");
// 2.打印对象特征
System.out.println(p1); // 张飞 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
}
}
//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{ // 保留父类的发现同时在子类中增加虚心的我根本就是
}
public class SubPersonTest {
public static void main(String[] args) {
// 1.声明SubPerson类型的引用指向SubPerson类型的对象并调用set方法进行测试
//SubPerson<String> sp1 = new SubPerson(); Error:SubPerson类中不支持泛型
SubPerson sp1 = new SubPerson();
sp1.setGender("女");
System.out.println("------------------------------------------");
//SubPerson<Boolean> sp2 = new SubPerson<>();
SubPerson<Boolean,String> sp2 = new SubPerson<>();
sp2.setGender(true);
}
}
自定义泛型方法
1.泛型方法就是我们输入参数的时候，输入的是泛型参数，而不是具体的参数。我们在调用这个泛型方法的时需要对泛型参数进行实例化
2.泛型方法的格式：
[访问权限] <泛型> 返回值类型 方法名([泛型标识 参数名称]) { 方法体; }
3.在静态方法中使用泛型参数的时候，需要我们把静态方法定义为泛型方法
/**
* @auther weiwei
* @date 2021/4/12 19:15
* @description 自定义泛型类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) {
// 5.调用方向方法进行测试
Integer[] arr = {11,22,33,44,55};
Person.printArray(arr); //11 22 33 44 55
}
}
泛型在继承上的体现
如果B是A的一个子类或子接口，而G是具有泛型声明的类或接口，则G并不是G的子类型！比如：String是Object的子类，但是List并不是List的子类
通配符的使用
1.希望传入的类型在一个指定的范围内，可以使用泛型通配符
如：之前传入的类型要求为Integer类型，但是后来业务需要Integer的父类Number类也可以传入
2.泛型中有三种通配符形式：
1）<?> 无限制通配符：表示我们可以传入任意类型的参数，不支持添加元素，支持获取元素
2）<? extends E> 表示类型的上界是E，只能是E或者是E的子类，不支持添加元素，支持获取元素
3）<? super E> 表示类型的下界是E，只能是E或者是E的父类
public class Animal {
}
public class Dog extends Animal{
}
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 = lt3; // 可以发生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);
}
}
Set集合（熟悉）
概念
1.java.util.Set集合是Collection集合的子集合，与List集合平级
2.集合中元素没有先后放入次序，且不允许重复
3.主要实现类是：HashSet类 和 TreeSet类以及LinkedHashSet类
4.HashSet类的底层是采用哈希表进行数据管理
5.TreeSet类的底层是采用红黑树进行数据管理
6.LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代
常用方法
参考Collection集合中的方法即可！
案例题目:
准备一个Set集合指向HashSet对象，向该集合中添加元素"two"并打印，再向集合中添加元素"one"并打印，再向集合中添加元素"three"并打印，再向集合中添加"one"并打印。
public class HashSetTest {
public static void main(String[] args) {
// 1.声明一个Set类型的引用指向HashSet类型的对象
Set<String> s1 = new HashSet<>();
//Set<String> s1 = new LinkedHashSet<>(); // 将放入的元素使用双向链表连接起来
System.out.println("s1 = " + s1); // [ ]
System.out.println("----------------------------");
// 2.向集合中添加元素并打印
boolean b1 = s1.add("two");
System.out.println("b1 = " + b1); // true
System.out.println("s1 = " + s1); // [two]
// 从打印结果上可以看到元素没有先后放入次序（表面）
b1 = s1.add("one");
System.out.println("b1 = " + b1); // true
System.out.println("s1 = " + s1); // [one, two] [two, one]
b1 = s1.add("three");
System.out.println("b1 = " + b1); // true
System.out.println("s1 = " + s1); // [one, two, three] [two, one, three]
// 验证元素不能重复
b1 = s1.add("one");
System.out.println("b1 = " + b1); // false
System.out.println("s1 = " + s1); // [one, two, three] [two, one, three]
}
}
元素放入HashSet集合的原理
1.使用元素调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算出该元素在数组中的索引位置
2.若该位置没有元素，则将该元素直接放入即可
3.若该位置有元素，则使用新元素与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入
4.若新元素与已有元素的哈希值相同，则使用新元素调用equals方法与已有元素依次比较
5.若相等则添加元素失败，否则将元素直接放入即可
**思考：**为什么要求重写equals方法后要重写hashCode方法呢？
解析：当两个元素调用equals方法相等时证明这两个元素相同，重写hashCode方法后保证这两个元素得到的哈希码值相同，由同一个哈希算法生成的索引位置相同，此时只需要与该索引位置已有元素比较即可，从而提高效率并避免重复元素的出现
TreeSet集合的概念
1.二叉树主要指每个节点最多只有两个子节点的树形结构
2.有序二叉树三个特征：
a.左子树中的任意节点元素都小于根节点元素值
b.右子树中的任意节点元素都大于根节点元素值
c.左子树和右子树的内部也遵守上述规则
3.TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使用新元素与集合中已有的元素依次比较来确定新元素的合理位置
4.比较元素大小的规则：
a.用元素的自然排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口
b.使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口
5.自然排序的规则比较单一，而比较器的规则比较多元化，而且比较器优先于自然排序
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
//return 0; // 调用对象和参数对象相等，调用对象就是新增加的对象
//return -1; // 调用对象小于参数对象
//return 1; // 调用对象大于参数对象
//return this.getName().compareTo(o.getName());
//return this.getAge() - o.getAge(); // 比较年龄
/* int ia = this.getName().compareTo(o.getName());
if(0 == ia){
return this.getAge() - o.getAge();
}
return ia;
*/
int ia = this.getName().compareTo(o.getName());
return 0 != ia ? ia : this.getAge() - o.getAge();
}
}
public class TreeSetTest {
public static void main(String[] args) {
// 1.准备一个TreeSet集合并打印
Set<String> s1 = new TreeSet<>();
System.out.println("s1 = " + s1); // [ ]
// 2.向集合中添加String类型的对象并打印
boolean b1 = s1.add("aa");
System.out.println("b1 = " + b1); // true
System.out.println("s1 = " + s1); // [aa]
b1 = s1.add("cc");
System.out.println("b1 = " + b1); // true
System.out.println("s1 = " + s1); // [aa, cc]
b1 = s1.add("bb");
System.out.println("b1 = " + b1); // true
// 由于TreeSet集合的底层是采用红黑树实现的，因此元素有大小次序，默认从小到大打印
System.out.println("s1 = " + s1); // [aa, bb, cc]
System.out.println("------------------------------------------------");
// 4.准备一个比较器对象作为参数传递给构造方法
// 匿名内部类：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
/*Comparator<Student> comparator = new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) { // o1b表示新增加的对象 o2表示集合中已有的对象
return o1.getAge() - o2.getAge(); // 按照年龄比较
}
};*/
// 从Java8开始支持Lambda表达式： （参数列表） -> { 方法体 }
Comparator<Student> comparator = (Student o1, Student o2) -> {return o1.getAge() - o2.getAge();};
// 3.准备一个TreeSet集合并放入Student类型的对象并打印
//Set<Student> s2 = new TreeSet<>();
Set<Student> s2 = new TreeSet<>(comparator);
s2.add(new Student("张飞",35));
s2.add(new Student("张飞",30));
s2.add(new Student("关羽",35));
s2.add(new Student("刘备",40));
System.out.println("s2 = " + s2);
}
}
Map集合（重点）
概念
1.java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，其中类型参数如下：
K - 此映射所维护的键(Key)的类型，相当于目录
V - 映射值(Value)的类型，相当于内容
2.key是不允许重复的，而且一个key只能对应一个value
3.主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、Properties类
4.HashMap类的底层是采用哈希表进行数据管理
5.TreeMap类的底层是采用红黑树进行数据管理
6.LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代
7.Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null为key或者value的数值
8.Properties类是Hashtable类的子类，该对象用于处理属性文件，key和value都是String类型的
9.Map集合是面向查询优化的数据结构, 在大数据量情况下有着优良的查询性能
10.经常用于根据key检索value的业务场景
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| 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视图（把map中所有的key拿出来组成一个Set集合） |
| Collection values() | 返回此映射中包含的值的Collection视图 |
| Set<Map.Entry<K,V>> entrySet() | 返回此集合中包含的映射的Set视图 |
public class MapTest {
public static void main(String[] args) {
// 1.准备一个Map集合并打印
Map<String,String> m1 = new HashMap<>();
// 自动掉用toString方法,默认打印格式为：{key1 = value1, key2 = value2,...}
// 2.向集合中添加元素并打印
String str1 = m1.put("1","one");
System.out.println("原来的value数值为：" + str1); // null
System.out.println("m1 = " + m1); // {1=one}
str1 = m1.put("2","two");
System.out.println("原来的value数值为：" + str1); // null
System.out.println("m1 = " + m1); // {1=one, 2=two}
str1 = m1.put("3","three");
System.out.println("原来的value数值为：" + str1); // null
System.out.println("m1 = " + m1); // {1=one, 2=two, 3=three}
// 实现了修改功能
str1 = m1.put("1","eleven");
System.out.println("原来的value数值为：" + str1); // one
System.out.println("m1 = " + m1); // {1=eleven, 2=two, 3=three}
System.out.println("---------------------------------------------");
// 3.实现集合中元素的查找操作
boolean b1 = m1.containsKey("11");
System.out.println("b1 = " + b1); // false
b1 = m1.containsKey("1");
System.out.println("b1 = " + b1); // true
b1 = m1.containsValue("one");
System.out.println("b1 = " + b1); // false
b1 = m1.containsValue("eleven");
System.out.println("b1 = " + b1); // true
String str2 = m1.get("5");
System.out.println("str2 = " + str2); // null
str2 = m1.get("3");
System.out.println("str2 = " + str2); // three
System.out.println("---------------------------------------------");
// 4.实现集合中元素的删除操作
str2 = m1.remove("1");
System.out.println("被删除的value是：" + str2); // eleven
System.out.println("m1 = " + m1); // {2=two, 3=three}
System.out.println("---------------------------------------------");
// 5.获取Map集合中所有的key并组成Set视图
Set<String> s1 = m1.keySet();
// 遍历所有的key
for (String ts:s1) {
System.out.println(ts + "=" + m1.get(ts));
}
System.out.println("---------------------------------------------");
// 6.获取Map集合中所有的value并组成Collection视图
Collection<String> co = m1.values();
for (String ts : co ) {
System.out.println("ts = " + ts);
}
System.out.println("---------------------------------------------");
// 7.获取Map集合中所有的键值对并组成Set视图
Set<Map.Entry<String, String>> entries = m1.entrySet();
for (Map.Entry<String, String> me: entries) {
System.out.println(me);
}
}
}
元素放入HashMap集合的原理
1.使用元素的key调用hashCode方法获取对应的哈希码值，再由某种哈希算法计算在数组中的索引位置
2.若该位置没有元素，则将该键值对直接放入即可
3.若该位置有元素，则使用key与已有元素依次比较哈希值，若哈希值不相同，则将该元素直接放入
4.若key与已有元素的哈希值相同，则使用key调用equals方法与已有元素依次比较
5.若相等则将对应的value修改，否则将键值对直接放入即可
相关的常量
1.DEFAULT_INITIAL_CAPACITY : HashMap的默认容量是16
2.DEFAULT_LOAD_FACTOR：HashMap的默认加载因子是0.75
3.threshold：扩容的临界值，该数值为：容量*填充因子，也就是12
4.TREEIFY_THRESHOLD：若Bucket中链表长度大于该默认值则转化为红黑树存储，该数值是8
5.MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量，该数值是64
Collections类
概念
java.util.Collections类主要提供了对集合操作或者返回集合的静态方法
常用方法
| 方法声明 | 功能介绍 |
|---|---|
| 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) | 交换指定列表中指定位置的元素 |
public class CollectionsTest {
public static void main(String[] args) {
// 1.准备一个集合并初始化
List<Integer> lt1 = Arrays.asList(10, 30, 20, 50, 45);
// 2.实现集合中元素的各种操作
System.out.println("集合中的最大值是：" + Collections.max(lt1)); // 50
System.out.println("集合中的最小值是：" + Collections.min(lt1)); // 10
// 实现集合中元素的反转操作
Collections.reverse(lt1);
System.out.println("lt1 = " + lt1); // [45, 50, 20, 30, 10]
// 实现两个元素的交换
Collections.swap(lt1,0,4);
System.out.println("交换后:lt1 = " + lt1); // [10, 50, 20, 30, 45]
// 实现元素的排序
Collections.sort(lt1);
System.out.println("排序后：lt1 = " + lt1); //[10, 20, 30, 45, 50]
// 随机置换
Collections.shuffle(lt1);
System.out.println("最忌置换后：lt1 = " + lt1);
// 实现集合间元素的拷贝
//List<Integer> lt2 = new ArrayList<>(20);
List<Integer> lt2 = Arrays.asList(new Integer[10]);
System.out.println("lt1的大小是：" + lt1.size());
System.out.println("lt2的大小是：" + lt2.size());
// 表示将lt1中的元素拷贝到lt2中
Collections.copy(lt2,lt1);
System.out.println("lt2 = " + lt2);
}
}
928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
