细谈深拷贝与浅拷贝

什么是深拷贝和浅拷贝

首先要明白深拷贝和浅拷贝都是针对一个已有对象的操作。在Java中，除了基本数据类型外，还存在类的实例对象这个引用数据类型。而一般使用=做赋值操作的时候，对于基本数据类型，实际上是拷贝他的值，但是对于对象而言，其实赋值的只是这个对象的引用，将原对象的引用传递过去，他们实际上还是指向的同一个对象。

如果在拷贝这个对象的时候，只针对基本数据类型进行了拷贝，而对引用数据类型只是进行了引用的传递，而没有真是的创建一个新的对象，则认为是浅拷贝。反之，在对引用数据类型进行深拷贝时，创建一个新的对象，并且复制其内的成员变量，则认为时深拷贝。

数据如何在内存中存储

JVM在程序运行的时候会将内存划分为四个区域

堆区，栈区，静态方法去，常量区

基本数据类型的局部变量

方法中的基本类型的局部变量，都是存储虚拟机的堆内存中的，数据本身的值就是存储在栈内存中。每次给一个新变量赋值的时候，JVM首先会检验内存中有无该数据，如果有，就直接将这个变量指向该数据，没有的话就开辟一个新的内存空间存放数据，然后将变量指向该数据。

int age = 50;
int weight = 50;
int height = 100;

看上面的代码段，三个变量都是某个方法中的局部变量，当执行int age = 50的时候，首先会定义变量，存入变量表中。然后去栈中找是否存在值为50的内容，并将age变量指向50.当执行int weight = 50时，会在栈中找到50，直接将weight指向50.当方法执行完毕以后，方法局部变量会被JVM的垃圾回收器回收。

基本数据类型的成员变量和引用类型变量

public class Student{
   private String name;
   private int age;
   private int grade;
}

 上面是一个Student类，如果我们重写toString方法，直接输出一个实例化对象的话，会得到这样的输出Student@1b6d3586,这个其实就是Student类的地址

所以，对于引用数据类型来说，引用数据类型只存储在一个堆内存中的地址，而成员变量和方法被存储在堆内存中。

 拷贝的引入

引用拷贝

创建一个指向对象的引用变量的拷贝

Teacher teacher = new Teacher("Taylor",26);
Teacher otherTeacher = teacher;;
System.out.println(teacher);
System.out.println(otherTeacher);


输出结果
blog.Teacher@335da254
blog.Teacher@335da254

由结果可以看出，他们的地址说相同的，所以肯定时同一个对象。teacher和otherTeacher只是引用而已，他们都指向了一个相同的对象Teacher("Taylor",26),这种叫做引用拷贝。

 对象拷贝

创建对象本身的一个副本

Teacher teacher = new Teacher("Taylor",26);
Teacher otherTeacher = (Teacher)teacher.clone();
System.out.println(teacher);
System.out.println(otherTeacher);


输出结果
blog.Teacher@335da254
blog.Teacher@4dc63996

由输出结果可以看出，他们的地址时不同的，也就是说创建了新的对象，而不是把原对象的地址付给了一个新的引用变量，这个叫做对象拷贝

 注意：深拷贝和浅拷贝都是对象拷贝

浅拷贝

被复制对象的所以变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象，就是说，浅拷贝仅仅复制所考虑的对象，而不会复制他所引用的对象。

package com.test;
 
public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("riemann");
        teacher.setAge(27);
 
        Student2 student1 = new Student2();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);
 
        Student2 student2 = (Student2) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
 
        System.out.println("修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("Games");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
 
    }
}
 
class Teacher implements Cloneable {
    private String name;
    private int age;
 
    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;
    }
}
 
class Student2 implements Cloneable {
    private String name;
    private int age;
    private Teacher teacher;
 
    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;
    }
 
    public Teacher getTeacher() {
        return teacher;
    }
 
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
 
    public Object clone() throws CloneNotSupportedException {
        Object object = super.clone();
        return object;
    }
}

这里的核心方法时Student类中的clone()方法

输出：

拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
Games

此时两个引用指向不同的两个对象，但是两个引用中的两个teacher引用指向的是同一个对象，所有说明是浅拷贝。

 深拷贝

深拷贝会拷贝所有的属性，并拷贝属性指向的动态分配内存。当对象和它所引用的对象一起拷贝时即发生深拷贝，相比于浅拷贝花销更大。也就是说，深拷贝把要复制的对象和引用的对象都要复制了一遍。

package com.test;
 
public class DeepCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher2 teacher = new Teacher2();
        teacher.setName("riemann");
        teacher.setAge(27);
 
        Student3 student1 = new Student3();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);
 
        Student3 student2 = (Student3) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());
 
        System.out.println("修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("Games");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }
}
 
class Teacher2 implements Cloneable {
    private String name;
    private int age;
 
    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;
    }
 
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
 
class Student3 implements Cloneable {
    private String name;
    private int age;
    private Teacher2 teacher;
 
    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;
    }
 
    public Teacher2 getTeacher() {
        return teacher;
    }
 
    public void setTeacher(Teacher2 teacher) {
        this.teacher = teacher;
    }
 
    public Object clone() throws CloneNotSupportedException {
        // 浅复制时：
        // Object object = super.clone();
        // return object;
 
        // 改为深复制：
        Student3 student = (Student3) super.clone();
        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
        student.setTeacher((Teacher2) student.getTeacher().clone());
        return student;
 
    }
}

输出：

拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
riemann

两个引用指向的是两个对象，两个teacher引用指向的也是两个对象，但对teacher对象的修改只能影响student1对象，所有是深拷贝

总结：

需要拷贝对象的时候，如果一个对象内部数据类型只有基本类型，那么就可以使用浅拷贝，如果一个对象内部还有引用数据类型，可以使用深拷贝。

文章部分摘自@AI乔治