Java的深拷贝与浅拷贝详解（java的深拷贝与浅拷贝详解图）
前言
拷贝，顾名思义，就是复制一个一模一样的东西。
那么放到对象上，也就是复制一个一模一样的对象了。
Java中的数据类型分为基本数据类型和引用数据类型。对于这两种数据类型，在进行赋值操作、用作方法参数或返回值时，会有值传递和引用（地址）传递的差别。
了解深拷贝和浅拷贝的原理，对于Java中的所谓值传递或者引用传递将会有更深的理解。
注意
下文中的很多代码意义的解释，我都放到代码注释里了，方便大家对照浏览，请仔细阅读代码。
浅拷贝(Shallow Copy)
一、简介
浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。即默认拷贝构造函数只是对对象进行浅拷贝复制(逐个成员依次拷贝)，即只复制对象空间而不复制对象资源。
二、特点
1、 对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。
基础类型的拷贝，其中一个对象修改该值，不会影响另外一个。
2、对于引用类型，比如数组或者类对象，因为引用类型是引用传递，所以浅拷贝只是把内存地址赋值给了成员变量，它们指向了同一内存空间。改变其中一个，会对另外一个也产生影响。
结构图如下：
上图中可以看出，基本数据类型的成员变量，对其值创建了新的拷贝；而引用数据类型的成员变量的实例仍然是只有一份，两个对象的该成员变量都指向同一个实例。
三、代码实现
核心步骤：
1、实现 Cloneable 接口
2、重写 clone() 方法
/**
* @author 头条：技术好奇心
* 学科类
*/
class Subject
{
// 学科名称
private String name;
// 构造方法
public Subject(String name) {
this.name = name;
}
// 获取学科名称
public String getName() {
return name;
}
// 设置学科名称
public void setName(String name) {
this.name = name;
}
// 重写toString()方法
@Override
public String toString() {
return "[科目: " + this.hashCode() + ",名称:" + name + "]";
}
}
/**
* @author 头条：技术好奇心
* 学生类
*/
class Student implements Cloneable {
// 科目对象（引用类型）
private Subject subject;
// 学生名称
private String name;
// 学生年龄
private int age;
// 获取学生科目对象
public Subject getSubject() {
return subject;
}
// 设置学生科目
public void setSubject(Subject subject) {
this.subject = subject;
}
// 获取学生姓名
public String getName() {
return name;
}
// 设置学生姓名
public void setName(String name) {
this.name = name;
}
// 获取学生年龄
public int getAge() {
return age;
}
// 设置学生年龄
public void setAge(int age) {
this.age = age;
}
// 重写clone()方法
@Override
public Object clone() {
//浅拷贝
try {
// 直接调用父类的clone()方法
return super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
@Override
public String toString() {
return "[学生: " + this.hashCode() + ",科目:" + subject + ",姓名:" + name + ",年龄:" + age + "]";
}
}
/**
* @author 头条：技术好奇心
* 浅拷贝实现类
*/
public class ShallowCopy
{
public static void main(String[] args)
{
// 创建语文对象
Subject subjectA = new Subject("语文");
// 创建学生对象A
Student studentA = new Student();
// 给学生A设置语文科目
studentA.setSubject(subjectA);
// 给学生A取名张三
studentA.setName("张三");
// 给学生A设定年龄为20岁
studentA.setAge(20);
// 通过clone()方法直接以克隆学生对象A的方式创建学生对象B
Student studentB = (Student) studentA.clone();
// 给学生B取名李四
studentB.setName("李四");
// 给学生B设定年龄为18岁
studentB.setAge(18);
// 尝试在未具体设置学生B科目的情况下，直接获取其科目对象
Subject subjectB = studentB.getSubject();
// 重新给科目B对象设置科目名称
subjectB.setName("数学");
// ------------ 来看看现在学生A和学生B两个对象中的具体值 ------------------
System.out.println("studentA:" + studentA.toString());
System.out.println("studentB:" + studentB.toString());
}
}
运行结果：
studentA:[学生: 460141958,科目:[科目: 1163157884,名称:数学],姓名:张三,年龄:20]
studentB:[学生: 1956725890,科目:[科目: 1163157884,名称:数学],姓名:李四,年龄:18]从上面运行结果可以看出，通过 studentA.clone() 拷贝对象后得到的 studentB，和 studentA 是两个不同的对象。studentA 和 studentB 的基础数据类型的修改互不影响，而引用类型 subject 修改后是会有影响的。
深拷贝(Deep Copy)
一、简介
深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。
从而解决了上面浅拷贝修改科目B会影响科目A的安全隐患。
二、特点
1、对于基本数据类型的成员对象，因为基础数据类型是值传递的，所以是直接将属性值赋值给新的对象。基础类型的拷贝，其中一个对象修改该值，不会影响另外一个（和浅拷贝一样）。
2、对于引用类型，比如数组或者类对象，深拷贝会新建一个对象空间，然后拷贝里面的内容，所以它们指向了不同的内存空间。改变其中一个，不会对另外一个也产生影响。
3、对于有多层对象的，每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的串行层层拷贝。
4、深拷贝相比于浅拷贝速度较慢并且花销较大。
结构图如下：
上图一目了然，对象克隆后，没有任何关联，是完全独立的两部分。
三、代码实现
/**
* @author 头条：技术好奇心
* 科目类 - 需要实现 Cloneable 并重写 clone() 方法。
*/
class DeepSubject implements Cloneable
{
// 科目名称
private String name;
// 构造方法
public DeepSubject(String name) {
this.name = name;
}
// 获取科目名称
public String getName() {
return name;
}
// 设置科目名称
public void setName(String name) {
this.name = name;
}
// 重写clone()方法
@Override
protected Object clone() throws CloneNotSupportedException {
//Subject 如果也有引用类型的成员属性，也应该和 Student 类的clone()方法一样通过其引用类型成员的实现（具体参见下面Student类）
return super.clone();
}
// 重写toString()方法
@Override
public String toString() {
return "[科目: " + this.hashCode() + ",名称:" + name + "]";
}
}
/**
* @author 头条：技术好奇心
* 学生类
*/
class DeepStudent implements Cloneable {
// 学科名称（引用类型）
private DeepSubject subject;
// 学生姓名
private String name;
// 学生年龄
private int age;
// 获取该学生的学科对象
public DeepSubject getSubject() {
return subject;
}
// 设置学生学科
public void setSubject(DeepSubject subject) {
this.subject = subject;
}
// 获取学生姓名
public String getName() {
return name;
}
// 设置学生姓名
public void setName(String name) {
this.name = name;
}
// 获取学生年龄
public int getAge() {
return age;
}
// 设置学生年龄
public void setAge(int age) {
this.age = age;
}
/**
* 重写clone()方法
* @return
*/
@Override
public Object clone() {
//深拷贝
try {
// 直接调用父类的clone()方法拷贝自己
DeepStudent student = (DeepStudent) super.clone();
// 通过对新的对象(student)的引用类型再调用拷贝操作，实现对引用类型成员变量 subject的深拷贝
student.subject = (DeepSubject) subject.clone();
return student;
} catch (CloneNotSupportedException e) {
return null;
}
}
@Override
public String toString() {
return "[学生: " + this.hashCode() + ",科目:" + subject + ",姓名:" + name + ",年龄:" + age + "]";
}
}
public class DeepCopy
{
public static void main(String[] args)
{
// 新建学科A语文
DeepSubject subjectA= new DeepSubject("语文");
// 新建学生A
DeepStudent studentA = new DeepStudent();
// 设置学生A的学科为语文
studentA.setSubject(subjectA);
// 给学生A取名王五
studentA.setName("王五");
// 给学生A设定年龄为19
studentA.setAge(19);
// 通过克隆学生A对象的方式创建学生B对象
DeepStudent studentB = (DeepStudent) studentA.clone();
// 设定学生B姓名为赵六
studentB.setName("赵六");
// 设置学生B的年龄为18
studentB.setAge(18);
// 同样的，这里也没有设置学生B的学科，直接获取B的学科对象
DeepSubject subjectB = studentB.getSubject();
// 将其学科对象设置为数学
subjectB.setName("数学");
// ---------------------- 这里我们再来看看，他与浅拷贝打印的区别 --------------------
System.out.println("studentA:" + studentA.toString());
System.out.println("studentB:" + studentB.toString());
}
}
运行结果：
studentA:[学生: 460141958,科目:[科目: 1163157884,名称:语文],姓名:王五,年龄:19]
studentB:[学生: 1956725890,科目:[科目: 356573597,名称:数学],姓名:赵六,年龄:18]看到没有，这里很明显，学生B设置自己的科目并没有对学生A产生影响。
由此可见，深拷贝后，不管是基础数据类型还是引用类型的成员变量，修改其值都不会相互造成影响。