本文介绍了Java中的Object类及其成员方法，如toString、equals和克隆（浅克隆与深克隆），以及如何重写equals方法。此外，还讨论了BigInteger和BigDecimal的用法，以及正则表达式的概念。
API
Object和Objects
Object
-
Object类是Java中的顶级父类，所有的类都直接或间接的继承于Object类；
-
Object类中的方法可以被所有子类访问，所以要学习Object类和其中的方法。
-
Object的构造方法：
public Object()：空参构造（顶级父类中只有无参构造方法）
-
Object的成员方法：
-
public String toString()：返回对象的字符串表示形式
-
public boolean equals(Object obj)：比较两个对象是否相等
-
protected Object clone(int a)：对象克隆
对象克隆：把A对象的属性值完全拷贝给B对象，也叫对象拷贝，对象复制。Object中的克隆是浅克隆
- 浅克隆：不管对象内部的属性是基本数据类型还是引用数据类型，都完全拷贝过来
- 深克隆：基本数据类型拷贝过来，字符串复用（串池），引用数据类型会重新创建新的（地址不再相同）
(1)ObjectDemo01:
/* - public String toString()：返回对象的字符串表示形式 - public boolean equals(Object obj)：比较两个对象是否相等 - protected Object clone(int a)：对象克隆 */ public class ObjectDemo01 { public static void main(String[] args) { //1.toString() 返回对象的字符串表示形式 Object obj = new Object(); String s = obj.toString(); System.out.println(s);//java.lang.Object@1b6d3586 //@后面的是对象的地址值 Student stu = new Student(); String s1 = stu.toString(); System.out.println(s1);//com.api.objectandobjects.Student@4554617c //细节： //System:类名 //out:静态变量 //Sytem.out:获取打印的对象 //println():方法 //参数：表示打印的内容 //核心逻辑： //当我们打印一个对象的时候，底层会调用对象的toString方法，把对象变成字符串 //然后再打印在控制台上，打印完毕换行处理 //思考：默认情况下，因为Object类中的toString方法返回的是地址值 //所以默认情况下，打印一个对象打印的就是地址值 //但是地址值对于我们是没有的什么意义的 //如果想要看到对象内部的属性值，该怎么办？ //处理方案：重写父类Object类中的toString方法 System.out.println(stu);//com.api.objectandobjects.Student@4554617c //在Student类中重写toString方法后，以上输出null,0(默认值) //toString方法的结论： //如果打印一个对象，想要看到属性值的话，那么就重写toString方法就可以了 //再重写的方法中，把对象的属性值进行拼接 } }(2)ObjectDemo02:
public class ObjectDemo02 { public static void main(String[] args) { /* - public boolean equals(Object obj)：比较两个对象是否相等 */ Student stu1 = new Student(); Student stu2 = new Student(); boolean result = stu1.equals(stu2); //因为Student类并没有重写父类Object类中的equals方法，所以 //调用的是Object类中的equals方法，该方法默认比较两个对象的地址值 //因为stu1和stu2都是new出来的，所以地址值不同 System.out.println(result);//false //重写equals方法后输出结果为true //结论： //1.如果没有重写equals方法，那么默认使用Object中的方法进行比较，比较的是地址值是否相等 //2.一般来讲地址值对于我们意义不大，所以我们会重写，重写之后比较的就是对象内部的属性值了 } }(3)ObjectDemo03:
public class ObjectDemo03 { public static void main(String[] args) { String s = "abc"; StringBuilder sb = new StringBuilder("abc"); System.out.println(s.equals(sb));//false //因为equals方法是被s调用的，而s是字符串 //所以equals要看String类中的 //字符串中的equals方法，先判断参数是否为字符串 //如果是字符串，再比较内部的属性 //但如果不是字符串，直接返回false System.out.println(sb.equals(s));//false //因为equals方法是被sb调用的，而sb是StringBuilder //所以这里的equals方法要看StringBuilder中的equals方法 //那么在StringBuidler当中，没有重写equals方法 //使用的是Object中的 //在Object中默认是使用==比较两个对象的地址值 //而这里的s和sb记录的地址值是不一样的，所以结果返回false } }(4)ObjectDemo04:
public class ObjectDemo04 { public static void main(String[] args) throws CloneNotSupportedException { /* - protected Object clone(int a)：对象克隆 */ //1.先创建一个对象 int[] data = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0}; User u1 = new User(1,"zhangsan","1234qwer","gir111",data); //2.克隆 //细节： //方法在底层会帮我们创建一个对象，并把原对象中的数据拷贝过去 //书写细节: //1.重写Object类中的clone方法 //2.让javabean类实现Cloneable接口 //3.创建原对象并调用clone就可以了 User u2 = (User) u1.clone(); //验证一件事：Object类中的克隆是浅克隆 int[] arr = u1.getData(); arr[0] = 100;//u1u2中的数组都改变了，代表都是一个地址，故为浅克隆 System.out.println(u1); System.out.println(u2); //u1的改变了但u2的未改变，因为此时User类中的克隆方法已重写为深克隆 } }(5)Student:
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } /** * 获取 * @return name */ public String getName() { return name; } /** * 设置 * @param name */ public void setName(String name) { this.name = name; } /** * 获取 * @return age */ public int getAge() { return age; } /** * 设置 * @param age */ public void setAge(int age) { this.age = age; } public String toString() { return "Student{name = " + name + ", age = " + age + "}"; } //重写之后的equals方法比较的就是对象内部的属性值了 @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); } }(5)User:
//Cloneable //如果一个接口里面没有抽象方法 //表示当前的接口是一个标记性接口 //现在Cloneable表示一旦实现了，那么当前类的对象就可以被克隆 //如果没有实现，当前类的对象就不能克隆 public class User implements Cloneable{ private int id;//游戏角色 private String username;//用户名 private String password;//密码 private String path;//游戏图片 private int[] data;//游戏进度 public User() { } public User(int id, String username, String password, String path, int[] data) { this.id = id; this.username = username; this.password = password; this.path = path; this.data = data; } /** * 获取 * @return id */ public int getId() { return id; } /** * 设置 * @param id */ public void setId(int id) { this.id = id; } /** * 获取 * @return username */ public String getUsername() { return username; } /** * 设置 * @param username */ public void setUsername(String username) { this.username = username; } /** * 获取 * @return password */ public String getPassword() { return password; } /** * 设置 * @param password */ public void setPassword(String password) { this.password = password; } /** * 获取 * @return path */ public String getPath() { return path; } /** * 设置 * @param path */ public void setPath(String path) { this.path = path; } /** * 获取 * @return data */ public int[] getData() { return data; } /** * 设置 * @param data */ public void setData(int[] data) { this.data = data; } public String toString() { return "角色编号为：" + id + ", 用户名：" + username + ", 密码：" + password + ", 游戏图片：" + path + ", 进度：" + arrToString(); } public String arrToString() { StringJoiner sj = new StringJoiner(",", "[", "]"); for (int i = 0; i < data.length; i++) { sj.add(data[i] + ""); } return sj.toString(); } @Override protected Object clone() throws CloneNotSupportedException { //调用父类中的clone方法 //相当于让Java帮我们克隆一个对象，并把克隆之后的对象返回出去 //先把被克隆对象中的数组获取出来 int[] data = this.data; //创建新的数组 int[] newData = new int[data.length]; //拷贝数组中的数据 for (int i = 0; i < data.length; i++) { newData[i] = data[i]; } //调用父类中的方法克隆对象 User u = (User)super.clone(); //因为父类中的克隆方法是浅克隆，替换克隆出来的对象中的数组地址值 u.data = newData; return u; } } -
Objects
Objects是一个工具类，提供了一些方法去完成一些功能。
- public static boolean equals(Object a,Object b)：先做非空判断，比较两个对象
- public static boolean isNull(Object obj)：判断对象是否为null,为null返回true，反之
- public static boolean nonNull(Object obj)：判断对象是否为null,跟isNull的结果相反
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
}
public class ObjectsDemo01 {
public static void main(String[] args) {
/*
1. public static boolean equals(Object a,Object b)：先做非空判断，比较两个对象
2. public static boolean isNull(Object obj)：判断对象是否为null,为null返回true，反之
3. public static boolean nonNull(Object obj)：判断对象是否为null,跟isNull的结果相反
*/
//1.创建学生类的对象
Student s1 = null;
Student s2 = new Student("zhangsan", 23);
//2.比较两个对象的属性值是否相同
/*
if (s1 != null) {
boolean result = s1.equals(s2);
System.out.println(result);//true
} else {
System.out.println("调用者为空");
}
*/
boolean result = Objects.equals(s1, s2);
System.out.println(result);
//细节：
//1.方法的底层会判断s1是否为null，如果为null，直接返回false
//2.如果s1不为null，那么就利用s1再次调用equals方法
//3.此时s1是Student类型，所以最终还是会调用Student中的equals方法
//如果没有重写，比较地址值，如果重写了就比较属性值
//public static boolean isNull(Object obj)：判断对象是否为null,为null返回true，反之
Student s3 = new Student();
Student s4 = null;
System.out.println(Objects.isNull(s3));//false
System.out.println(Objects.isNull(s4));//true
System.out.println(Objects.nonNull(s3));//true
System.out.println(Objects.nonNull(s4));//false
}
}
BigInteger和BigDecimal
BigInteger
BigInteger表示的数字没有超出long的范围
- public BigInteger(int num,Random rnd)：获取随机大整数，范围：[0-2的num次方-1]
- public BigInteger(String val)：获取指定的大整数
- public BigInteger(String val，int radix)：获取指定进制的大整数
- public static BigInteger valueOf(long val)：静态方法获取BigInteger的对象，内部有优化
构造方法小结：
- 如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取
- 如果BigInteger表示的数字超出long的范围，可以用构造方法获取
- 对象一旦创建，内部记录的值不能发生改变
- 只要进行计算都会产生一个新的BigInteger对象
public class BigIntegerDemo01 {
public static void main(String[] args) {
/*
1. public BigInteger(int num,Random rnd)：获取随机大整数，范围：[0-2的num次方-1]
2. public BigInteger(String val)：获取指定的大整数
3. public BigInteger(String val，int radix)：获取指定进制的大整数
4. public static BigInteger valueOf(long val)：静态方法获取BigInteger的对象，内部有优化
细节：
对象一旦创建，内部记录的值不能发生改变
*/
//1.获取一个随机的大整数
/*Random rd = new Random();
BigInteger bd1 = new BigInteger(4, rd);
System.out.println(bd1);//0-2^4-1*/
//2.获取一个指定的大整数
BigInteger bd2 = new BigInteger("10099999999999999");
System.out.println(bd2);
//3.获取指定进制的大整数
//细节：
//1.字符串中的数字必须是整数
//2.字符串中的数字必须要跟进制吻合
//比如二进制中，那么只能写0和1，写其他的就报错
BigInteger bd3 = new BigInteger("100", 10);
System.out.println(bd3);//100
//4.静态方法获取BigInteger的对象，内部有优化
//细节：
//1.能表示范围比较小，只能在long的取值范围之内，如果超出long的范围就不行了
//2.在内部对常用的数字：-16 - 16进行了优化
//提前把-16 - 16先创建好BigInteger的对象，如果多次获取不会重新创建新的
/*BigInteger bd4 = BigInteger.valueOf(9223372036854775807L);
System.out.println(bd4);
BigInteger bd5 = BigInteger.valueOf(16);
BigInteger bd6 = BigInteger.valueOf(16);
System.out.println(bd5 == bd6);//true
BigInteger bd7 = BigInteger.valueOf(17);
BigInteger bd8 = BigInteger.valueOf(17);
System.out.println(bd7 == bd8);//false*/
//5.对象一旦创建内部数据不能发生改变
BigInteger bd9 = BigInteger.valueOf(1);
BigInteger bd10 = BigInteger.valueOf(2);
BigInteger result = bd9.add(bd10);
System.out.println(result);//3
//此时，不会修改参与计算的BigInteger对象的值，而是产生了一个新的BigInteger对象记录3
System.out.println(bd9 == result);//false
System.out.println(bd10 == result);//false
}
}
正则表达式
说明：
以上笔记学习是学习b站黑马程序员时记下的笔记，仅限于帮助理解学习，不做任何其他商业用途。
956
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
