1.API,常用应用接口,就是别人已经写好的程序。以前的文章稍微学过。
2.Object类,Java中所有类的祖宗,一般都会使用Object中的一些方法。
(1)toString方法,返回字符串的表示形式,一般返回的是内存地址,所以需要我们在类中重写一下toSpring方法,来输出它的内容。
(2)equals方法,比较两个对象是否相等,比较的是两个对象的地址是否一致。双等于号也可以比较地址,所以一般我们也需要重写equals方法,让两个对象比较内容。
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 重写 equals 方法,比较两个对象的内容一样就返回 true
// 比较者:s2 == this
// 被比较者:s1 == o
@Override
public boolean equals(Object o) {
// 1. 判断两个对象是否是地址一样。一样直接返回 true
if (this == o) return true;
// 2. 判断 o 是否为 null,或类型是否不同。类型不同直接返回 false
// 用 getClass 比较类对象,不用 instanceof,因为 instance 类返回类对象,包括子类。
if (o == null || this.getClass() != o.getClass()) return false;
// 3. o 不是 null,且 o 一定是学生类对象。开始比较内容!
Student student = (Student) o;
return this.age == student.age && Objects.equals(name, student.name);
}
public static void main(String[] args) {
Student s1 = new Student("Alice", 20);
Student s2 = new Student("Alice", 20);
Student s3 = new Student("Bob", 22);
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
}
}
(3)clone方法,生成副本。首先重写clone方法,非object的子类需要super.clone(),然后实现克隆接口,被称为浅克隆。
浅克隆是指考本出的新对象,与原对象中的数据一模一样,拷贝的只是地址。
深克隆指的是基本类型的数据还是直接拷贝,例如数字啥的,字符串数据拷贝的还是地址,其他对象不会拷贝地址,而是新建一个对象,例如数组。
3.Objects类
Objects是一个工具类,提供了很多操作对象的静态方法供我们使用
(1)Objects.equals(Object a, Object b): 比较两个对象是否相等(处理了 null 情况,不会出bug)。
import java.util.Objects;
public class test {
public static void main(String[] args) {
String s1 = null;
String s2 = "lzk";
// 会抛出 NullPointerException
System.out.println(s1.equals(s2));
// 不会抛出异常,安全地进行比较
System.out.println(Objects.equals(s1, s2)); // 输出 false
}
}
(2)Objects.isNull(Object obj): 检查对象是否为 null。
(3)Objects.nonNull(Object obj): 检查对象是否不是 null。
4.包装类
一般都是大写,有两个是不同的
import java.util.ArrayList;
public class test {
public static void main(String[] args) {
// 目标:掌握包装类的使用。
// 手动装箱:将基本类型转换为包装类对象
// Integer a1 = new Integer(12); // 不推荐使用,因为它已经过时
Integer a2 = Integer.valueOf(12); // 推荐使用,手动装箱
System.out.println(a2);
// 自动装箱:可以自动地将基本类型的数据转换成对象
Integer a3 = 12; // 自动装箱
// 自动拆箱:可以自动包裹类的对象转换成对应的基本类型数据
int a4 = a3; // 自动拆箱
// 泛型集合不支持基本数据类型,只能支持引用数据类型
// ArrayList<int> list = new ArrayList<>(); // 错误
// 使用包装类 Integer
ArrayList<Integer> list = new ArrayList<>();
list.add(12); // 自动装箱
list.add(13); // 自动装箱
int rs = list.get(1); // 自动拆箱
System.out.println(rs);
//1.基本类型转成字符串
Integer a = 23;
// 方法1:使用 Integer.toString()
String rs1 = Integer.toString(a); // "23"
System.out.println(rs1); // 输出 "23"
System.out.println(rs1 + 1); // 输出 "231",字符串拼接
// 方法2:使用 Integer 对象的 toString()
String rs2 = a.toString(); // "23"
System.out.println(rs2); // 输出 "23"
System.out.println(rs2 + 1); // 输出 "231",字符串拼接
// 方法3:使用字符串拼接!!!!!常用
String rs3 = a + ""; // "23"
System.out.println(rs3); // 输出 "23"
System.out.println(rs3 + 1); // 输出 "231",字符串拼接
//2.把字符串类型数值!!!转成对应的基本类型
String str = "123";//要是数值,而且没有小数,只能转成int,带小数,要用double
// 方法1:使用 Integer.parseInt()
int rs4 = Integer.parseInt(str); // 123
System.out.println(rs4); // 输出 123
// 方法2:使用包装类 Integer 的 valueOf()!!!!!常用
int rs6 = Integer.valueOf(str); // 123
System.out.println(rs6); // 输出 123
}
}
5.StringBuilder
代表可变字符串对象,相当于是一个容器,他里边装的字符串是可以改变的,就是用来操作字符串的。StringBuilder比String更适合字符串操作。效率更高,更简洁。
public class test {
public static void main(String[] args) {
// 目标:搞清楚 StringBuilder 的用法和作用。
// StringBuilder s = new StringBuilder(); // s 空字符串
StringBuilder s = new StringBuilder("lzk"); // s "lzk"
// 1. 拼接内容
s.append(12);
s.append("冲冲冲");
s.append(true);
// 支持链式编程
s.append(666).append("杀杀杀").append(666);
System.out.println(s); // 输出 "lzk12冲冲冲true666杀杀杀666"
// 2. 反转操作
s.reverse();
System.out.println(s); // 应该是反转后的字符串
// 3. 返回字符串的长度
System.out.println(s.length()); // 打印字符序列的长度
// 4. 把 StringBuilder 对象转换成 String 类型
String rs = s.toString();
System.out.println(rs); // 打印转换后的字符串
}
}
频繁修改或者增加,使用StringBuilder比String更好
public class test {
public static void main(String[] args) {
// 目标:掌握 StringBuilder 的好处。
// 需求:要拼接 100 万次 abc
// 下面注释掉的部分是使用 String 测试看看的性能
// String rs = "";
// for (int i = 1; i <= 1000000; i++) {
// rs = rs + "abc";
// }
// System.out.println(rs);
// 使用 StringBuilder 演示
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= 1000000; i++) {
sb.append("abc");
}
System.out.println(sb);
}
}
6.StringBudder
Stringbuffer与SringBuilder用法一致,但是前者线程安全,后者线程不安全。
7.案例
设计一个方法,用于返回任意整型数组的内容,返回数组格式如[11, 22, 33]
接受并返回数据,使用StringBuilder拼接。
public class test {
public static void main(String[] args) {
// 目标:完成遍历数组内容,并拼接成指定格式的案例。
System.out.println(getArrayData(new int[]{11, 22, 33}));
}
public static String getArrayData(int[] arr) {
// 1. 判断 arr 是否为 null
if (arr == null) {
return null;
}
// 2. arr 数组对象存在 arr = [11, 22, 33]
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
// 最后一个元素
sb.append(arr[i]);
} else {
// 其他元素,后面加上逗号和空格
sb.append(arr[i]).append(", ");
}
}
sb.append("]");
return sb.toString();
}
}
8.StringJoiner
与StringBuilder功能一样,代码更简洁
import java.util.StringJoiner;
public class test {
public static void main(String[] args) {
// 使用分隔符创建 StringJoiner 对象
StringJoiner joiner1 = new StringJoiner(", ");
joiner1.add("Alice");
joiner1.add("Bob");
joiner1.add("Charlie");
System.out.println(joiner1); // 输出 "Alice, Bob, Charlie"
System.out.println("Length: " + joiner1.length()); // 输出长度 18
// 使用分隔符、前缀和后缀创建 StringJoiner 对象
StringJoiner joiner2 = new StringJoiner(", ", "[", "]");
joiner2.add("Apple");
joiner2.add("Banana");
joiner2.add("Cherry");
System.out.println(joiner2); // 输出 "[Apple, Banana, Cherry]"
System.out.println("Length: " + joiner2.length()); // 输出长度 22
}
}
public class test {
public static void main(String[] args) {
// 打印格式化后的数组数据
System.out.println(getArrayData(new int[]{11, 22, 33}));
}
public static String getArrayData(int[] arr) {
// 1. 判断 arr 是否为 null
if (arr == null) {
return null;
}
// 2. arr 数组对象存在,例: arr = [11, 22, 33]
StringJoiner s = new StringJoiner(", ", "[", "]");
for (int i = 0; i < arr.length; i++) {
s.add(String.valueOf(arr[i]));
//或者 s.add(arr[i]+"");
}
return s.toString();// 返回格式化后的数组数据
}
}