Java中深拷贝（Deep Copy）和浅拷贝(Shallow Copy)学习笔记

由于在线程安全中涉及到对象的深度拷贝（Deep Copy），很早以前听说多，不多是TypeScript中听一个同事介绍，但是自己对java这块的知识还不了解，于是就打算借此机会学一下深浅拷贝，并加深一下相关技术的印象。于是查阅了一些资料，现将知识点整理如下归为以下几类进行整理：

• 借用图形展示深浅拷贝的区别及特点
• Object类中clone（）方法实现深浅拷贝
• 实际应用中深浅拷贝的区别
• 其他扩展知识

一、 图形表述深浅拷贝的区别和特点

1. 再回顾内存表示示意图

我记得我在Java堆栈介绍介绍中详细介绍了Java的堆、栈及其他们在JVM中的存在形式，再次回顾时，更加清晰，先了解下图，会对理解后续介绍有所帮助。

讨论深浅拷贝的前提

深浅拷贝基本上都是讨论引用类型对象的变量（类的对象，String类等），对于基本数据类型的变量，深浅拷贝都是要复制的。用下图介绍深浅拷贝的区别（图片来源：https://blog.csdn.net/qq_32252957/article/details/82782249）：

先介绍几点概念便于理解：

• 对象（存放在图一中的堆区，一般空间较大）的复制：在堆中单独开辟一块地址空间，用于存放与该对象内容完全相同的一个对象，地址是不同的；
• 对象内部可能包含很多成员变量，这些成员变量又指向不同的对象，所以大部分对象是由很多其他对象组合而成的（一般情况下）。
  浅拷贝：只复制当前对象，对该对象内部的引用不能复制。
  深拷贝：对对象内部所有对象的引用均复制，每个引用对象创建一个实例并复制实例。

也就是说，他们主要区别在于复制对象本身时是否进一步递归复制子对象。

二、Object类中的clone（）方法实现深浅拷贝及相关注意事项

java内存模型

在开始已经很浅显、简略的介绍了内存模型，更详细的可以看一下JVM（能力有限，作者看了一遍有些地方还是未懂，需要进一步积累再返看，不过好处是对有些内容进一步加深了理解）。这里只介绍内存模型中的堆和栈。

• 栈：存放基本类型的变量数据、局部变量、和对象的引用，但对象本身是放在堆中的（new 出来的对象）或者常量池中（目前接触的好像只有**字符串常量对象）！！！！
• 堆：用来存放new产生的对象数据，数组。这里有一点特别注意：创建出来的对象只包含属于各自的成员变量，并不包括成员方法。因为同一个类的对象拥有各自的成员变量，存储在各自的堆中，但是他们共享该类的方法，并不是创建一个对象就把成员方法复制一次。（作者可算更明白了JVM为什么搞一个方法区，当初看的真的很晦涩难懂，自己又不想死记硬背_……）。

“==” 和equals()的区别

以下几点细节仔细思考*****************

• 对于基本数据类型(int,float,double,byte,short,long,boolean,char)，只能用==
• 对于基本数据类型的封装类(Boolean,Integer,Long,Float,Double)，==比较的是指向对象的地址，比较的是栈内存中存放的对象的引用（地址），equals比较的是值。（这个也好理解，包装类还是一般的类！）
• 如果是类对象，那么在对象的类没有重写equals()方法时，==和equals都是比较地址。如果覆盖了equals()方法，根据实际情况比较。
• String类，Data类都重写了equals方法，所以比较地址，equals比较值。（String倒是亲身体验过，Data类倒还没有深入研究过，String的是根据对象来比较的，比较特殊的一种对象）

clone()方法的使用

Java中父类java.lang.Object提供了clone()方法，但考虑到安全性问题，一方面将clone()方法的访问级别设置为protected类型，限制外部类访问，另一方面，强制需要提供clone功能的子类实现java.lang.Cloneable接口。总结就是如果一个类需要被克隆，该类需要实现clone方法和实现Cloneable接口，缺一不可
在java中使用clone()方法如何判别深浅拷贝呢，就是判断拷贝后的对象是否相等，即判断两对象的地址是否相同。B=clone(A),AB为真否。以下图为例：p1是对象1的引用变量，对象1含有对对象2和对象3的引用；p2是p1的clone()。执行p1.对象1p2.对象1（这里需要注意一下，这种表示实际比较的是两个引用指向的对象2是否相等，容易看成指向对象1）为ture，因为他们共同保存对象2的引用。p1==p2为false,因为指向不同的地址。

下面从三个角度说明clone()如何体现深浅拷贝。

对象自身的复制

Clone()方法只复制当前对象，对于没有内部引用的对象，p2克隆p1后，两个对象指向不同的地址，p1==p2操作返回false。如下图：

示例代码：

package clone;
class  Person implements Cloneable{ // 实现Cloneable接口
    int age;
    String name;
    public  Person(int a, String b){
        age=a;
        name=b;
    }
    public Person(Person p){ // 用一个对象来构造另一个对象
        this.age=p.age;
        this.name=p.name;
    }
@Override
public Object clone() {
    Person per=null;    
    try {
            per=(Person)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return  per;
}
 
}
public class Body {
    public static void main(String[] args){
        Person p1=new Person(10,"wang");
        Person p2 = (Person) p1.clone();
        System.out.println(p1);//输出堆内存的地址
        System.out.println(p2);
        System.out.println(p2.age);
        System.out.println(p1==p2);
    }
 
}

输出：

clone.Person@532760d8
clone.Person@57fa26b7
10
false

这说明clone()之后两对象地址不同，但是值相同。

不含子对象的情况下，浅复制不会clone子对象

当Person类含有其他对象的引用时（含有其他类的对象），增加一个类student，内含成绩grade这个元素，该类对象要作为Person类的成员，添加内部引用。调用clone方法会发现其他对象的引用并没有克隆成功。
如下图：

示例代码：

package clone;

class Student{
    String grade;
    public Student(){
    }
    public void  setGrade(String a){
        this.grade=a;
    }
}
class  Person2 implements Cloneable{
    int age;
    String name;
    Student  grades;
    public void setGrades(Student gra){
        this.grades=gra;
    }
    public  Person2(int a, String b,Student gra){
        age=a;
        name=b;
        this.grades=gra;
    }
    public Person2(Person2 p){
        this.age=p.age;
        this.name=p.name;
    }
@Override
public Object clone() {
    Person2 per=null;    
    try {
            per=(Person2)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return  per;
}
}
public class Body2 {
    public static void main(String[] args){
        Student stu=new Student();
        stu.setGrade("100");
        Person2 p1=new Person2(10,"wang",stu);
        Person2 p2 = (Person2)  p1.clone();
        System.out.println(p1.grades==p2.grades);
        // 检验子对象的值有没有被修改
        System.out.println("*******检验子对象的值有没有被修改********");
        stu.setGrade("200");
        System.out.println(p2.grades.grade);
        System.out.println(p1.grades.grade);

    }
}

输出：

true
检验子对象的值有没有被修改*
200
200
这说明：

• 浅拷贝没有复制子对象，否则会为子对象单独申请空间创建实例并为其赋相同值；
• 对象1和被复制出来的对象1所指向的子对象是同一个，子对象值一改之后，两个访问到的值都是被改之后的。

重写clone方法，变成深拷贝之后，将复制子对象

下面仔细的重写下clone方法，变成深拷贝，影响到原对象。

示例代码：

package clone;
class Student1 implements Cloneable{
    String grade;
    public Student1(){
 
    }
    public void  setGrade(String a){
        this.grade=a;
    }
    public Object clone(){
        Student1 stu=null;
        try {
            stu=(Student1)super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return stu;
    }
}
class  Person3 implements Cloneable{
    int age;
    String name;
    Student1  grades;
    public void setGrades(Student1 gra){
        this.grades=gra;
    }
    public  Person3(int a, String b,Student1 gra){
        age=a;
        name=b;
        this.grades=gra;
    }
    public Person3(Person3 p){
        this.age=p.age;
        this.name=p.name;
        this.grades=p.grades;
    }
@Override
public Object clone() {
    Person3 per=null;    
    try {
            per=(Person3)super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    per.grades=(Student1)grades.clone();//深拷贝：就是对引用的对象单独拷贝一次哦。
        return  per;
}
 
}
public class Body3 {
    public static void main(String[] args){
        // TODO Auto-generated method stub
        Student1 stu=new Student1();
        stu.setGrade("100");
        Person3 p1=new Person3(10,"wang",stu);
        Person3 p2 = (Person3)  p1.clone();
        System.out.println(p1.grades==p2.grades);
        // 检验子对象的值有没有被修改
        System.out.println("*******检验子对象的值有没有被修改********");
        stu.setGrade("200");
        System.out.println(p2.grades.grade);
        System.out.println(p1.grades.grade);

    }
 
}

输出

false
检验子对象的值有没有被修改*
100
200

这说明：

• 可以通过重写clone方法实现深度复制的实现；
• 执行结果为200和100，说明的确不是指向同一个对象了(相同引用)，而是单独指向，不再一变全变。

实际应用中深浅拷贝的区别

• 如果拆开来对对象2的元素依次赋值，这样的肯定就是深度复制了。例如p2.grades=new Student(){}因为这样是明显的创建新实例来进行赋值，没有传递引用等操作。
• Person a2=a1;//最显而易见的浅复制，全是引用，只是用另一个引用指向同一块地址。

其他知识的扩展

本来想借此机会总结下：不一定要通过构造器创建对象这个命题！比如这里的clone（）方法，但是有点多，也比较晚了，留个连接供自己学习和分享。Java之deep copy(深复制)