目录
- Java对象复制
- 1,直接赋值
- 2,浅拷贝
- 3,深拷贝
- 4,序列化拷贝
Java对象复制
将一个对象的引用复制给另一个对象,一共有三种方式。第一种是直接赋值,第二种方式是浅拷贝,第三种是深拷贝,这三种方式实际上都是为了拷贝对象。
1,直接赋值
为了测试方便,新建两个类,没有实际的业务功能,只是为了测试。
//用了lombok插件,生成get,set方法,有参构造与无参构造
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private Integer id;
private String name;
private Integer age;
private Student student;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
private Integer id;
private Integer score;
}
public class CopyTest {
public static void main(String[] args) {
Student student = new Student(1, 80);
User user1 = new User(1, "zhangSan", 25, student);
System.out.println("user1==>"user1.toString());
// 采用直接赋值的方式复制
User user2=user1;
// 改变原对象中的值
user1.setAge(26);
// 改变复制后对象的值
user2.setName("zhangSan1");
// 因为user1给年龄重新赋值了,对象user2中的年龄对应的值也会改变
// user1和user2是指向同一块内存的两个指针
System.out.println("user2==>"user2.toString());
}
}
输出:
user1==>User(id=1, name=zhangSan, age=25, student=Student(id=1, score=80))
user2==>User(id=1, name=zhangSan1, age=26, student=Student(id=1, score=80))
直接赋值相当于是指针赋值,user1和user2这两个对象都是指向同一块内存,只要其中任何一个改变相应的值,两个都会一起变化。
2,浅拷贝
创建一个新对象,然后将当前对象的非静态字段复制到该对象,如果字段是值类型,那么对该字段进行复制;如果该字段是引用类型的话,则复制引用但不复制引用的对象。 因此,原始对象及其副本引用同一个对象。
浅拷贝需要继承Cloneable接口,重写clone()方法。
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Cloneable {
private Integer id;
private String name;
private Integer age;
private Student student;
@Override
public Object clone(){
try{
return (User) super.clone();
}catch (Exception e){
e.printStackTrace();
return null;
}
}
}
public class CopyTest {
public static void main(String[] args) {
Student student = new Student(1, 80);
User user1 = new User(1, "zhangSan", 25, student);
System.out.println("user1==>"+user1.toString());
// 深拷贝:调用User的clone方法
User user2 = (User) user1.clone();
// 改变原对象中的值
user1.setAge(26);
// 原对象的引用类型重新赋值
user1.getStudent().setScore(90);
// 改变复制后对象的值
user2.setName("zhangSan1");
// 从输出结果可以看出,值类型的age,name两个对象互不影响
// 引用类型的student,当user1中改变时,复制对象user2没有变,说明引用类型的字段也被拷贝了一份
System.out.println("user2==>"+user2.toString());
System.out.println("user1==>"+user1.toString());
}
}
输出:
user1==>User(id=1, name=zhangSan, age=25, student=Student(id=1, score=80))
user2==>User(id=1, name=zhangSan1, age=25, student=Student(id=1, score=90))
user1==>User(id=1, name=zhangSan, age=26, student=Student(id=1, score=90))
可以发现原对象user1中的Student引用类型对应的值改变后,拷贝对象user2中的student值也跟着变了,说明拷贝后的对象中的引用类型与原对象的引用是同一个。
3,深拷贝
深拷贝不仅复制对象本身,而且复制对象包含的引用指向的所有对象。
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student implements Cloneable {
private Integer id;
private Integer score;
@Override
public Object clone(){
try{
return (Student) super.clone();
}catch (Exception e){
e.printStackTrace();
return null;
}
}
}
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Cloneable {
private Integer id;
private String name;
private Integer age;
private Student student;
@Override
public Object clone() {
User user = null;
try {
user = (User) super.clone();
} catch (Exception e) {
e.printStackTrace();
}
user.student = (Student) student.clone();//调用student的clone方法
return user;
}
}
public class CopyTest {
public static void main(String[] args) {
Student student = new Student(1, 80);
User user1 = new User(1, "zhangSan", 25, student);
System.out.println("user1==>"+user1.toString());
// 深拷贝:调用User的clone方法
User user2 = (User) user1.clone();
// 改变原对象中的值
user1.setAge(26);
// 原对象的引用类型重新赋值
user1.getStudent().setScore(90);
// 改变复制后对象的值
user2.setName("zhangSan1");
// 从输出结果可以看出,值类型的age,name两个对象互不影响
// 引用类型的student,当user1中改变时,复制对象user2没有变,说明引用类型的字段也被拷贝了一份
System.out.println("user2==>"+user2.toString());
System.out.println("user1==>"+user1.toString());
}
}
输出:
user1==>User(id=1, name=zhangSan, age=25, student=Student(id=1, score=80))
user2==>User(id=1, name=zhangSan1, age=25, student=Student(id=1, score=80))
user1==>User(id=1, name=zhangSan, age=26, student=Student(id=1, score=90))
原user1对象中student引用的实例值改变了,拷贝后的对象中引用的实例值没有变,说明它们两个不是同一个引用。
4,序列化拷贝
在Java语言里深复制一个对象,常常可以先使对象实现Serializable接口,然后把对象(实际上只是对象的一个拷贝),写到一个流里,再从流里读出来,便可以重建对象。
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student implements Serializable {
private Integer id;
private Integer score;
}
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
private Integer id;
private String name;
private Integer age;
private Student student;
}
public class CopyTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
Student student = new Student(1, 80);
User user = new User(1, "zhangSan", 25, student);
//ByteArrayOutputStream: 可以捕获内存缓冲区的数据,转换成字节数组。
//ByteArrayInputStream: 可以将字节数组转化为输入流
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(bo);
objectOutputStream.writeObject(user);//将user对象,以字节数组的形式写入到内层缓冲区中
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(bi);
User newUser = (User) objectInputStream.readObject();//反序列化,生成对象(深拷贝)
student.setScore(90);
System.out.println(user);
System.out.println(newUser);
}
}
输出:
User(id=1, name=zhangSan, age=25, student=Student(id=1, score=90))
User(id=1, name=zhangSan, age=25, student=Student(id=1, score=80))