深拷贝与浅拷贝的详细讲解

在中级、初级程序员面试时，通常会被问到深拷贝与浅拷贝，这很显然是基础中的基础，如果没有回答好，的确是会影响面试结果。

一、什么是拷贝？

基本数据类型、引用数据类型在赋值的时候，就是在拷贝。通俗理解就是“复制”，浅拷贝就是复制了一份地址值，深拷贝就是复制了一份内容。

二、什么是拷贝的深与浅？

基本数据类型在赋值时，因为赋值的是数据，所以没有深浅问题。

引用数据类型在赋值时，赋值的是地址，所以存在深浅问题。

三、什么是浅拷贝？

只拷贝了地址，没有拷贝数据，也就是没有开辟新的内存空间。

四、什么是深拷贝？

既拷贝了地址，也拷贝了数据，也就是开辟了新的内存空间。

五、浅拷贝代码举例

public 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;
    }

    @Override
    public String toString() {
        return "[Subject: " + this.hashCode() + ",name:" + name + "]";
    }
}

public 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()方法
     * @return
     */
    @Override
    public Object clone() {
        //浅拷贝
        try {
            // 直接调用父类的clone()方法
            return super.clone();
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

    @Override
    public String toString() {
        return "[Student: " + this.hashCode() + ",subject:" + subject + ",name:" + name + ",age:" + age + "]";
    }
}

public class ShallowCopy {
    public static void main(String[] args) {
        Student studentA = new Student();
        studentA.setSubject(new Subject("语文"));
        studentA.setName("张三");
        studentA.setAge(20);
        //调用StudentA的clone方法，生成StudentB对象
        Student studentB = (Student) studentA.clone();
        studentB.setName("李四");
        studentB.setAge(18);
        //修改引用类型的值
        studentB.getSubject().setName("数学");
        System.out.println("studentA:" + studentA.toString());
        System.out.println("studentB:" + studentB.toString());
    }
}

studentA:[Student: 1828972342,subject:[Subject: 1452126962,name:数学],name:张三,age:20]
studentB:[Student: 931919113,subject:[Subject: 1452126962,name:数学],name:李四,age:18]

由此案例，通过将studentA对象拷贝成studentB对象时，我们可以看到，修改基本数据类型互不影响，但是修改引用数据，对studentB进行赋值时，也修改了studentA 的值。这也就证明了上面提到的：基本数据类型的拷贝没有深浅问题；浅拷贝没有开辟新的内存空间，指向的又是同一个内存地址，所以只是值进行了覆盖。

六、深拷贝代码举例

通过上面的例子可以看到，浅拷贝会带来数据安全方面的隐患，例如我们只是想修改了 studentB 的 subject，但是 studentA 的 subject 也被修改了，因为它们都是指向的同一个内存地址。所以，此种情况下，我们需要用到深拷贝。

深拷贝，在拷贝引用类型成员变量时，为引用类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝。

在引用数据类型中实现 Cloneable 并重写 clone() 方法。

public class Subject implements Cloneable {

    private String name;

    public Subject(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "[Subject: " + this.hashCode() + ",name:" + name + "]";
    }
}

此处是关键点，实现了引用类型的深拷贝，做法就是：将studentA拷贝成studentB之后，对studentB对象的引用类型再次进行拷贝，此时两个对象的引用类型的地址值则区分开了，从而实现了对象的引用类型的深拷贝。

public 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()方法
     * @return
     */
    @Override
    public Object clone() {
        //深拷贝
        try {
            //直接调用父类的clone()方法
            Student student = (Student) super.clone();
            //同时新增引用类型的克隆
            student.subject = (Subject) subject.clone();
            return student;
        } catch (CloneNotSupportedException e) {
            return null;
        }
    }

    @Override
    public String toString() {
        return "[Student: " + this.hashCode() + ",subject:" + subject + ",name:" + name + ",age:" + age + "]";
    }
}

同样的测试代码

public class ShallowCopy {
    public static void main(String[] args) {
        Student studentA = new Student();
        studentA.setSubject(new Subject("语文"));
        studentA.setName("张三");
        studentA.setAge(20);
        //调用StudentA的clone方法，生成StudentB对象
        Student studentB = (Student) studentA.clone();
        studentB.setName("李四");
        studentB.setAge(18);
        //修改引用类型的值
        studentB.getSubject().setName("数学");
        System.out.println("studentA:" + studentA.toString());
        System.out.println("studentB:" + studentB.toString());
    }
}

不同的结果：

studentA:[Student: 1828972342,subject:[Subject: 1452126962,name:语文],name:张三,age:20]
studentB:[Student: 931919113,subject:[Subject: 1607521710,name:数学],name:李四,age:18]

七、对象拷贝和浅拷贝的区别

将Student studentB = (Student) studentA.clone();替换成Student studentB = studentA;

public class ShallowCopy {
    public static void main(String[] args) {
        Student studentA = new Student();
        studentA.setSubject(new Subject("语文"));
        studentA.setName("张三");
        studentA.setAge(20);
        //调用StudentA的clone方法，生成StudentB对象
        Student studentB = studentA;
        studentB.setName("李四");
        studentB.setAge(18);
        //修改引用类型的值
        studentB.getSubject().setName("数学");
        System.out.println("studentA:" + studentA.toString());
        System.out.println("studentB:" + studentB.toString());
    }
}

输出结果：

studentA:[Student: 1828972342,subject:[Subject: 1452126962,name:数学],name:李四,age:18]
studentB:[Student: 1828972342,subject:[Subject: 1452126962,name:数学],name:李四,age:18]
由此可见：

对象拷贝并没有像浅拷贝那样生成新的对象studentB，两者的地址值还是一模一样，只是更换了对象的引用。