再見：深拷貝、淺拷貝問題！

時間 2020-08-29

標籤再見拷貝問題简体版

原文原文鏈接

對象拷貝在咱們平常寫代碼的時候基本上是剛性需求，常常遇到，只不過不少人每天忙於寫業務，忽視了一些細節問題和理解，有時候這方面一旦出了問題，就不太容易排查了。git

因此本篇好好梳理一下。github

注：本文已收錄於Github開源項目： github.com/hansonwang99/JavaCollection ，裏面有詳細自學編程學習路線、面試題和麪經、編程資料及系列技術文章等，資源持續更新中...

值類型 vs 引用類型

這兩個概念的區分，對於深、淺拷貝問題的理解很是重要。面試

正如Java聖經《Java編程思想》第二章的標題所言，在Java中一切均可以視爲對象，因此來到Java的世界，像數組、類Class、枚舉Enum、Integer包裝類等等，就是典型的引用類型；編程

可是Java的語言級基礎數據類型，諸如int這些基本類型，操做時通常也是採起的值傳遞方式，因此有時候也稱它爲值類型。數組

爲了便於下文的講述和舉例，咱們這裏先定義兩個類：Student和Major，分別表示「學生」以及「所學的專業」，兩者是包含關係：ide

`// 學生的所學專業
public class Major {
    private String majorName; // 專業名稱
    private long majorId;     // 專業代號

    // ... 其餘省略 ...
}
`學習

`// 學生
public class Student {
    private String name;  // 姓名
    private int age;      // 年齡
    private Major major;  // 所學專業

    // ... 其餘省略 ...
}
`測試

賦值 vs 淺拷貝 vs 深拷貝

對象賦值

賦值是平常編程過程當中最多見的操做，最簡單的好比：this

`Student codeSheep = new Student();
Student codePig = codeSheep;
`spa

嚴格來講，這種不能算是對象拷貝，由於拷貝的僅僅只是引用關係，並無生成新的實際對象：

淺拷貝

淺拷貝屬於對象克隆方式的一種，重要的特性體如今這個 「淺」 字上。

好比咱們試圖經過studen1實例，拷貝獲得student2，若是是淺拷貝這種方式，大體模型能夠示意成以下所示的樣子：

很明顯，值類型的字段會複製一份，而引用類型的字段拷貝的僅僅是引用地址，而該引用地址指向的實際對象空間其實只有一份。

一圖勝前言，我想上面這個圖已經表現得很清楚了。

深拷貝

深拷貝相較於上面所示的淺拷貝，除了值類型字段會複製一份，引用類型字段所指向的對象，會在內存中也建立一個副本，就像這個樣子：

原理很清楚明瞭，下面來看看具體的代碼實現吧。

淺拷貝代碼實現

還以上文的例子來說，我想經過student1拷貝獲得student2，淺拷貝的典型實現方式是：讓被複制對象的類實現Cloneable接口，並重寫clone()方法便可。

以上面的Student類拷貝爲例：

`public class Student implements Cloneable {

    private String name;  // 姓名
    private int age;      // 年齡
    private Major major;  // 所學專業

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

    // ... 其餘省略 ...

}
`

而後咱們寫個測試代碼，一試便知：

`public class Test {

public static void main(String[] args) throws CloneNotSupportedException {

        Major m = new Major("計算機科學與技術",666666);
        Student student1 = new Student( "CodeSheep", 18, m );

        // 由 student1 拷貝獲得 student2
        Student student2 = (Student) student1.clone();

        System.out.println( student1 == student2 );
        System.out.println( student1 );
        System.out.println( student2 );
        System.out.println( "n" );

        // 修改student1的值類型字段
        student1.setAge( 35 );

        // 修改student1的引用類型字段
        m.setMajorName( "電子信息工程" );
        m.setMajorId( 888888 );

System.out.println( student1 );
System.out.println( student2 );

}
}
`

運行獲得以下結果：

從結果能夠看出：

student1==student2打印false，說明clone()方法的確克隆出了一個新對象；
修改值類型字段並不影響克隆出來的新對象，符合預期；
而修改了student1內部的引用對象，克隆對象student2也受到了波及，說明內部仍是關聯在一塊兒的
- *

深拷貝代碼實現

深度遍歷式拷貝

雖然clone()方法能夠完成對象的拷貝工做，可是注意：clone()方法默認是淺拷貝行爲，就像上面的例子同樣。若想實現深拷貝需覆寫 clone()方法實現引用對象的深度遍歷式拷貝，進行地毯式搜索。

因此對於上面的例子，若是想實現深拷貝，首先須要對更深一層次的引用類Major作改造，讓其也實現Cloneable接口並重寫clone()方法：

`public class Major implements Cloneable {

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

    // ... 其餘省略 ...
}
`

其次咱們還須要在頂層的調用類中重寫clone方法，來調用引用類型字段的clone()方法實現深度拷貝，對應到本文那就是Student類：

`public class Student implements Cloneable {

    @Override
    public Object clone() throws CloneNotSupportedException {
        Student student = (Student) super.clone();
        student.major = (Major) major.clone(); // 重要！！！
        return student;
    }

    // ... 其餘省略 ...
}
`

這時候上面的測試用例不變，運行可得結果：

很明顯，這時候student1和student2兩個對象就徹底獨立了，不受互相的干擾。

利用反序列化實現深拷貝

記得在前文《序列化/反序列化，我忍你好久了》中就已經詳細梳理和總結了「序列化和反序列化」這個知識點了。

利用反序列化技術，咱們也能夠從一個對象深拷貝出另外一個複製對象，並且這貨在解決多層套娃式的深拷貝問題時效果出奇的好。

因此咱們這裏改造一下Student類，讓其clone()方法經過序列化和反序列化的方式來生成一個原對象的深拷貝副本：

`public class Student implements Serializable {

    private String name;  // 姓名
    private int age;      // 年齡
    private Major major;  // 所學專業

    public Student clone() {
        try {
            // 將對象自己序列化到字節流
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream =
                    new ObjectOutputStream( byteArrayOutputStream );
            objectOutputStream.writeObject( this );

            // 再將字節流經過反序列化方式獲得對象副本
            ObjectInputStream objectInputStream =
                    new ObjectInputStream( new ByteArrayInputStream( byteArrayOutputStream.toByteArray() ) );
            return (Student) objectInputStream.readObject();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return null;
    }

    // ... 其餘省略 ...
}
`

固然這種狀況下要求被引用的子類（好比這裏的Major類）也必須是能夠序列化的，即實現了Serializable接口：

`public class Major implements Serializable {

  // ... 其餘省略 ...

}
`

這時候測試用例徹底不變，直接運行，也能夠獲得以下結果：