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
}
}- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
(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
}
}- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
(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
}
}- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.
- 51.
- 52.
- 53.
- 54.
- 55.
- 56.
- 57.
- 58.
- 59.
- 60.
- 61.
- 62.
- 63.
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); // 打印转换后的字符串
}
}- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
频繁修改或者增加，使用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);
}
}- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
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();
}
}- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
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
}
}- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
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();// 返回格式化后的数组数据
}
}- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
6035
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
