深拷貝與淺拷貝詳解

轉自：https://blog.csdn.net/baiye_xing/article/details/71788741

1.拷貝的引入

（1）引用拷貝

創建一個指向對象的引用變量的拷貝。

例1：

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

輸出結果：

blog.Teacher@355da254
blog.Teacher@355da254

結果分析：由輸出結果可以看出，它們的地址值是相同的，那麼它們肯定是同一個對象。teacher和otherteacher的只是引用而已，他們都指向了一個相同的對象Teacher(“Taylor”,26)。 這就叫做引用拷貝。

例1 圖解： 

（2）對象拷貝

創建對象本身的一個副本。

例2：

Teacher teacher = new Teacher("Swift",26);
Teacher otherteacher = (Teacher)teacher.clone();
System.out.println(teacher);
System.out.println(otherteacher);

輸出結果:

blog.Teacher@355da254
blog.Teacher@4dc63996

結果分析：由輸出結果可以看出，它們的地址是不同的，也就是說創建了新的對象， 而不是把原對象的地址賦給了一個新的引用變量,這就叫做對象拷貝。

例2 圖解： 

注：深拷貝和淺拷貝都是對象拷貝

2.淺拷貝

（1）定義：

被複制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。即對象的淺拷貝會對“主”對象進行拷貝，但不會複製主對象裏面的對象。”裏面的對象“會在原來的對象和它的副本之間共享。

簡而言之，淺拷貝僅僅複製所考慮的對象，而不復制它所引用的對象

（2）淺拷貝實例：

例3：

package blog;

/**
 * Created by 白夜行 on 2017/5/8.
 */
public class ShallowCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher();
        teacher.setName("Delacey");
        teacher.setAge(29);

        Student2 student1 = new Student2();
        student1.setName("Dream");
        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("Jam");
        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;
    }

    @Override
    public Object clone() throws CloneNotSupportedException
    {
        Object object = super.clone();
        return object;
    }

}

輸出結果：

拷貝後
Dream
18
Delacey
29
修改老師的信息後-------------
Jam
Jam

結果分析： 兩個引用student1和student2指向不同的兩個對象，但是兩個引用student1和student2中的兩個teacher引用指向的是同一個對象，所以說明是淺拷貝。

例3 圖解： 

3.深拷貝

（1）定義：

深拷貝是一個整個獨立的對象拷貝，深拷貝會拷貝所有的屬性,並拷貝屬性指向的動態分配的內存。當對象和它所引用的對象一起拷貝時即發生深拷貝。深拷貝相比於淺拷貝速度較慢並且花銷較大。

簡而言之，深拷貝把要複製的對象所引用的對象都複製了一遍。

（2）實現深拷貝（實例1）：

例4：

package blog;

/**
 * Created by 白夜行 on 2017/5/8.
 */

public class DeepCopy {
    public static void main(String[] args) throws Exception
    {
        Teacher2 teacher = new Teacher2();
        teacher.setName("Delacey");
        teacher.setAge(29);

        Student3 student1 = new Student3();
        student1.setName("Dream");
        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("Jam");
        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;
    }

    @Override
    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;
    }

    @Override
    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;
    }

}

輸出結果：

拷貝後
Dream
18
Delacey
29
修改老師的信息後-------------
Jam
Delacey

結果分析： 
兩個引用student1和student2指向不同的兩個對象，兩個引用student1和student2中的兩個teacher引用指向的是兩個對象，但對teacher對象的修改只能影響student1對象,所以說是深拷貝。

例4 圖解1（teacher姓名Delacey更改前）：

例4 圖解2（teacher姓名Jam更改後）：

（3）利用序列化實現深拷貝（實例2）

例5：

package blog;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * Created by 白夜行 on 2017/5/13.
 */
public class DeepCopyServiable {
    public static void main(String[] args) throws Exception {
        Teacher3 t = new Teacher3();
        t.setName("Taylor");
        t.setAge(28);

        Student3 s1 = new Student3();
        s1.setAge(20);
        s1.setName("blank space");
        s1.setTeacher(t);

        Student3 s2 = (Student3) s1.deepClone();

        System.out.println("拷貝後:");
        System.out.println(s2.getName());
        System.out.println(s2.getAge());
        System.out.println(s2.getTeacher().getName());
        System.out.println(s2.getTeacher().getAge());
        System.out.println("---------------------------");

        t.setName("swift");

        System.out.println("修改後：");
        System.out.println(s1.getTeacher().getName());
        System.out.println(s2.getTeacher().getName());
    }

}

class Teacher3 implements Serializable
{
    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 Student3 implements Serializable
{
    private String name;
    private int age;
    private Teacher3 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 Teacher3 getTeacher()
    {
        return teacher;
    }

    public void setTeacher(Teacher3 teacher)
    {
        this.teacher = teacher;
    }

    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();
    }

}

輸出結果：

拷貝後:
blank space
20
Taylor
28
---------------------------
修改後：
swift
Taylor

結果分析：說明用序列化的方式實現了對象的深拷貝