Java 轻松理解深拷贝与浅拷贝
前言
本文代码中有用到一些注解，主要是Lombok与junit用于简化代码。
主要是看到一堆代码会很乱，这样理解更清晰。如果没用过不用太过纠结。
对象的拷贝（克隆）是一个非常高频的操作，主要有以下三种方式：
- 直接赋值
- 拷贝：
- 浅拷贝
- 深拷贝
因为Java没有指针的概念，或者说是不需要我们去操心，这让我们省去了很多麻烦，但相应的，对于对象的引用、拷贝有时候就会有些懵逼，藏下一些很难发现的bug。
为了避免这些bug，理解这三种操作的作用与区别就是关键。
直接赋值
用等于号直接赋值是我们平时最常用的一种方式。
它的特点就是直接引用等号右边的对象
先来看下面的例子
先创建一个Person类
@Data
@AllArgsConstructor
@ToString
public class Person{
private String name;
private int age;
private Person friend;
}
测试
@Test
public void test() {
Person friend =new Person("老王",30,null);
Person person1 = new Person("张三", 20, null);
Person person2 = person1;
System.out.println("person1: " + person1);
System.out.println("person2: " + person2 + "\n");
person1.setName("张四");
person1.setAge(25);
person1.setFriend(friend);
System.out.println("person1: " + person1);
System.out.println("person2: " + person2);
}
结果
person1: Person(name=张三, age=20, friend=null)
person2: Person(name=张三, age=20, friend=null)
person1: Person(name=张四, age=25, friend=Person(name=老王, age=30, friend=null))
person2: Person(name=张四, age=25, friend=Person(name=老王, age=30, friend=null))
分析：
可以看到通过直接赋值进行拷贝，其实就只是单纯的对前对象进行引用。
如果这些对象都是基础对象当然没什么问题，但是如果对象进行操作，相当于两个对象同属一个实例。
拷贝
直接赋值虽然方便，但是很多时候并不是我们想要的结果，很多时候我们需要的是两个看似一样但是完全独立的两个对象。
这种时候我们就需要用到一个方法clone()
clone()并不是一个可以直接使用的方法，需要先实现Cloneable接口，然后重写它才能使用。
protected native Object clone() throws CloneNotSupportedException;
clone()方法被native关键字修饰，native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是系统或者其他语言来实现。
浅拷贝
浅拷贝可以实现对象克隆，但是存在一些缺陷。
定义：
- 如果原型对象的成员变量是值类型，将复制一份给克隆对象，也就是在堆中拥有独立的空间；
- 如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，指向相同的内存地址。
举例
光看定义不太好一下子理解，上代码看例子。
我们先来修改一下Person类，实现Cloneable接口，重写clone()方法，其实很简单，只需要用super调用一下即可
@Data
@AllArgsConstructor
@ToString
public class Person implements Cloneable {
private String name;
private int age;
private Friend friend;
@Override
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
-------
@Data
@AllArgsConstructor
public class Friend {
private String Name;
}
测试
@Test
public void test() {
Person person1 = new Person("张三", 20, "老王");
Person person2 = (Person) person1.clone();
System.out.println("person1: " + person1);
System.out.println("person2: " + person2 + "\n");
person1.setName("张四");
person1.setAge(25);
person1.setFriend("小王");
System.out.println("person1: " + person1);
System.out.println("person2: " + person2);
}
结果
person1: Person(name=张三, age=20, friend=Friend(Name=老王))
person2: Person(name=张三, age=20, friend=Friend(Name=老王))
person1: Person(name=张四, age=25, friend=Friend(Name=小王))
person2: Person(name=张三, age=20, friend=Friend(Name=小王))
可以看到，name age基本对象属性并没改变，而friend引用对象熟悉变了。
原理
Java浅拷贝的原理其实是把原对象的各个属性的地址拷贝给新对象。
注意我说的是各个属性，就算是基础对象属性其实也是拷贝的地址。
你可能有点晕了，都是拷贝了地址，为什么修改了 person1 对象的 name age 属性值，person2 对象的 name age 属性值没有改变呢？
我们一步步来，拿name属性来说明：
- String、Integer 等包装类都是不可变的对象
- 当需要修改不可变对象的值时，需要在内存中生成一个新的对象来存放新的值
- 然后将原来的引用指向新的地址
- 我们修改了
person1对象的name属性值，person1对象的name字段指向了内存中新的String对象 - 我们并没有改变
person2对象的 name 字段的指向，所以person2对象的name还是指向内存中原来的String地址
看图
这个图已经很清晰的展示了其中的过程，因为person1 对象改变friend时是改变的引用对象的属性，并不是新建立了一个对象进行替换，原本老王的消失了，变成了小王。所以person2也跟着改变了。
深拷贝
深拷贝就是我们拷贝的初衷了，无论是值类型还是引用类型都会完完全全的拷贝一份，在内存中生成一个新的对象。
拷贝对象和被拷贝对象没有任何关系，互不影响。
深拷贝相比于浅拷贝速度较慢并且花销较大。
简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。
因为Java本身的特性，对于不可变的基本值类型，无论如何在内存中都是只有一份的。
所以对于不可变的基本值类型，深拷贝跟浅拷贝一样，不过并不影响什么。
实现：
想要实现深拷贝并不难，只需要在浅拷贝的基础上进行一点修改即可。
- 给friend添加一个
clone()方法。 - 在
Person类的clone()方法调用friend的clone()方法，将friend也复制一份即可。
@Data
@ToString
public class Person implements Cloneable {
private String name;
private int age;
private Friend friend;
public Person(String name, int age, String friend) {
this.name = name;
this.age = age;
this.friend = new Friend(friend);
}
public void setFriend(String friend) {
this.friend.setName(friend);
}
@Override
public Object clone() {
try {
Person person = (Person)super.clone();
person.friend = (Friend) friend.clone();
return person;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
}
------
@Data
@AllArgsConstructor
public class Friend implements Cloneable{
private String Name;
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
测试
@Test
public void test() {
Person person1 = new Person("张三", 20, "老王");
Person person2 = (Person) person1.clone();
System.out.println("person1: " + person1);
System.out.println("person2: " + person2 + "\n");
person1.setName("张四");
person1.setAge(25);
person1.setFriend("小王");
System.out.println("person1: " + person1);
System.out.println("person2: " + person2);
}
结果
person1: Person(name=张三, age=20, friend=Friend(Name=老王))
person2: Person(name=张三, age=20, friend=Friend(Name=老王))
person1: Person(name=张四, age=25, friend=Friend(Name=小王))
person2: Person(name=张三, age=20, friend=Friend(Name=老王))
分析：
可以看到这次是真正的完全独立了起来。
需要注意的是，如果Friend类本身也存在引用类型，则需要在Friend类中的clone()，也去调用其引用类型的clone()方法，就如是Person类中那样，对！就是套娃！
所以对于存在多层依赖关系的对象，实现Cloneable接口重写clone()方法就显得有些笨拙了。
这里我们在介绍一种方法：利用序列化实现深拷贝
Serializable 实现深拷贝
修改Person和Friend，实现Serializable接口
@Data
@ToString
public class Person implements Serializable {
// ......同之前
public Object deepClone() throws Exception {
// 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
}
---
@Data
@AllArgsConstructor
public class Friend implements Serializable {
private String Name;
}
测试
@Test
public void test() {
Person person1 = new Person("张三", 20, "老王");
Person person2 = null;
try {
person2 = (Person) person1.deepClone();
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("person1: " + person1);
System.out.println("person2: " + person2 + "\n");
person1.setName("张四");
person1.setAge(25);
person1.setFriend("小王");
System.out.println("person1: " + person1);
System.out.println("person2: " + person2);
}
结果
person1: Person(name=张三, age=20, friend=Friend(Name=老王))
person2: Person(name=张三, age=20, friend=Friend(Name=老王))
person1: Person(name=张四, age=25, friend=Friend(Name=小王))
person2: Person(name=张三, age=20, friend=Friend(Name=老王))
只要将会被复制到的引用对象标记Serializable接口，通过序列化到方式即可实现深拷贝。
原理：
对象被序列化成流后，因为写在流里的是对象的一个拷贝，而原对象仍然存在于虚拟机里面。
通过反序列化就可以获得一个完全相同的拷贝。
利用这个特性就实现了对象的深拷贝。
总结
- 直接赋值是将新的对象指向原对象所指向的实例，所以一旦有所修改，两个对象会一起变。
- 浅拷贝是把原对象属性的地址传给新对象，对于不可变的基础类型，实现了二者的分离，但对于引用对象，二者还是会一起改变。
- 深拷贝是真正的完全拷贝，二者没有关系。实现深拷贝时如果存在多层依赖关系，可以采用序列化的方式来进行实现。
对于
Serializable接口、Cloneable接口，其实都是相当于一个标记，点进去看源码，其实他们是一个空接口。
