淺拷貝和深拷貝(談談java中的clone)

阿新 • • 發佈：2019-01-02

clone顧名思義就是複製，在Java語言中， clone方法被物件呼叫，所以會複製物件。所謂的複製物件，首先要分配一個和源物件同樣大小的空間，在這個空間中建立一個新的物件。那麼在java語言中，有幾種方式可以建立物件呢？
1. 使用new操作符建立一個物件
2. 使用clone方法複製一個物件
那麼這兩種方式有什麼相同和不同呢？ new操作符的本意是分配記憶體。程式執行到new操作符時，首先去看new操作符後面的型別，因為知道了型別，才能知道要分配多大的記憶體空間。分配完記憶體之後，再呼叫建構函式，填充物件的各個域，這一步叫做物件的初始化，構造方法返回後，一個物件建立完畢，可以把他的引用（地址）釋出到外部，在外部就可以使用這個引用操縱這個物件。而clone在第一步是和new相似的，都是分配記憶體，呼叫clone方法時，分配的記憶體和源物件（即呼叫clone方法的物件）相同，然後再使用原物件中對應的各個域，填充新物件的域，填充完成之後，clone方法返回，一個新的相同的物件被建立，同樣可以把這個新物件的引用釋出到外部。【

詳解Java中的clone方法】

引用的拷貝

    //引用拷貝
    private static void copyReferenceObject(){
        Person p = new Person(23, "zhang");
        Person p1 = p;
        System.out.println(p);
        System.out.println(p1);
    }

這裡列印的結果：
[email protected]
[email protected]
可以看到，列印的結果是一樣的，也就是說，二者的引用是同一個物件，並沒有創建出一個新的物件。因此要區分引用拷貝和物件拷貝的區別，下面要介紹的就是物件拷貝。

淺拷貝

淺拷貝是按位拷貝物件，它會建立一個新物件，這個物件有著原始物件屬性值的一份精確拷貝。如果屬性是基本型別，拷貝的就是基本型別的值；如果屬性是記憶體地址（引用型別），拷貝的就是記憶體地址，因此如果其中一個物件改變了這個地址，就會影響到另一個物件。

實現物件拷貝的類，必須實現Cloneable介面，並覆寫clone()方法。
Persion類：

package com.yaolong.clone;

public class Person implements Cloneable{

    //private Integer age;
    private int 
 age;//阿里規範中規定pojo類中的屬性強制使用包裝型別，這裡只是測試

    private String name;

    public Person(Integer age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return super.toString();
    }

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

    //物件拷貝
    private static void copyRealObject() throws CloneNotSupportedException{
        Person p = new Person(23, "zhang");
        Person p1 = (Person) p.clone();      
        System.out.println(p);
        System.out.println(p1);
    }

這裡列印的結果：
[email protected]
[email protected]
可以看出，二者的物件地址不一樣，因此實現了拷貝。

但是還是有個問題，就是Person類中有一個String型別的引用物件name，它真的也被拷貝過去了嗎，還是說依然是引用的是同一個name物件呢，在上面的程式碼基礎上，我們繼續列印：

        System.out.println("pName："+p.getName().hashCode());
        System.out.println("p1Name："+p1.getName().hashCode());

這裡列印的結果：
pName：115864556
p1Name：115864556
可見，二者的name屬性依然是指向同一個物件。上面故意將age屬性改為int基本型別，因為基本資料型別是不存在引用問題。
這實際上就是典型的淺拷貝：

深拷貝的記憶體圖：

由上可知，從Object中繼承過來的clone預設實現的是淺拷貝。

深拷貝

深拷貝會拷貝所有的屬性,並拷貝屬性指向的動態分配的記憶體。當物件和它所引用的物件一起拷貝時即發生深拷貝。深拷貝相比於淺拷貝速度較慢並且花銷較大。

現在為了要在clone物件時進行深拷貝，那麼就要Clonable介面，覆蓋並實現clone方法，除了呼叫父類中的clone方法得到新的物件，還要將該類中的引用變數也clone出來。如果只是用Object中預設的clone方法，是淺拷貝的。

static class Body implements Cloneable{
    public Head head;

    public Body() {}

    public Body(Head head) {this.head = head;}

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

}
static class Head /*implements Cloneable*/{
    public  Face face;

    public Head() {}
    public Head(Face face){this.face = face;}

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

    Body body = new Body(new Head());

    Body body1 = (Body) body.clone();

    System.out.println("body == body1 : " + (body == body1) );

    System.out.println("body.head == body1.head : " +  (body.head == body1.head));


}

在以上程式碼中，有兩個主要的類，分別為Body和Face，在Body類中，組合了一個Face物件。當對Body物件進行clone時，它組合的Face物件只進行淺拷貝。
列印結果可以驗證該結論：
body == body1 : false
body.head == body1.head : true

如果要使Body物件在clone時進行深拷貝，那麼就要在Body的clone方法中，將源物件引用的Head物件也clone一份。

static class Body implements Cloneable{
    public Head head;
    public Body() {}
    public Body(Head head) {this.head = head;}

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Body newBody =  (Body) super.clone();
        newBody.head = (Head) head.clone();
        return newBody;
    }

}
static class Head implements Cloneable{
    public  Face face;

    public Head() {}
    public Head(Face face){this.face = face;}
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
} 
public static void main(String[] args) throws CloneNotSupportedException {

    Body body = new Body(new Head());

    Body body1 = (Body) body.clone();

    System.out.println("body == body1 : " + (body == body1) );

    System.out.println("body.head == body1.head : " +  (body.head == body1.head));


}

列印結果為： body == body1 : false
body.head == body1.head : false

由此可見， body和body1內的head引用指向了不同的Head物件，也就是說在clone Body物件的同時，也拷貝了它所引用的Head物件，進行了深拷貝。

真的是深拷貝嗎

由上一節的內容可以得出如下結論：如果想要深拷貝一個物件，這個物件必須要實現Cloneable介面，實現clone方法，並且在clone方法內部，把該物件引用的其他物件也要clone一份，這就要求這個被引用的物件必須也要實現Cloneable介面並且實現clone方法。
那麼，按照上面的結論， Body類組合了Head類，而Head類組合了Face類，要想深拷貝Body類，必須在Body類的clone方法中將Head類也要拷貝一份，但是在拷貝Head類時，預設執行的是淺拷貝，也就是說Head中組合的Face物件並不會被拷貝。驗證程式碼如下：（這裡本來只給出Face類的程式碼就可以了，但是為了閱讀起來具有連貫性，避免丟失上下文資訊，還是給出整個程式，整個程式也非常簡短）

static class Body implements Cloneable{
    public Head head;
    public Body() {}
    public Body(Head head) {this.head = head;}

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Body newBody =  (Body) super.clone();
        newBody.head = (Head) head.clone();
        return newBody;
    }

}

static class Head implements Cloneable{
    public  Face face;

    public Head() {}
    public Head(Face face){this.face = face;}
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
} 

static class Face{}

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

    Body body = new Body(new Head(new Face()));

    Body body1 = (Body) body.clone();

    System.out.println("body == body1 : " + (body == body1) );

    System.out.println("body.head == body1.head : " +  (body.head == body1.head));

    System.out.println("body.head.face == body1.head.face : " +  (body.head.face == body1.head.face));


}

列印結果為：
body == body1 : false
body.head == body1.head : false
body.head.face == body1.head.face : true

那麼，對Body物件來說，算是這算是深拷貝嗎？其實應該算是深拷貝，因為對Body物件內所引用的其他物件（目前只有Head）都進行了拷貝，也就是說兩個獨立的Body物件內的head引用已經指向了獨立的兩個Head物件。但是，這對於兩個Head物件來說，他們指向了同一個Face物件，這就說明，兩個Body物件還是有一定的聯絡，並沒有完全的獨立。這應該說是一種不徹底的深拷貝。

如何進行徹底的深拷貝

對於上面的例子來說，怎樣才能保證兩個Body物件完全獨立呢？只要在拷貝Head物件的時候，也將Face物件拷貝一份就可以了。這需要讓Face類也實現Cloneable介面，實現clone方法，並且在在Head物件的clone方法中，拷貝它所引用的Face物件。修改的部分程式碼如下：

static class Head implements Cloneable{
    public  Face face;

    public Head() {}
    public Head(Face face){this.face = face;}
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //return super.clone();
        Head newHead = (Head) super.clone();
        newHead.face = (Face) this.face.clone();
        return newHead;
    }
} 

static class Face implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

再次執行上面的示例，得到的執行結果如下： body == body1 : false
body.head == body1.head : false
body.head.face == body1.head.face : false

這說名兩個Body已經完全獨立了，他們間接引用的face物件已經被拷貝，也就是引用了獨立的Face物件。

依此類推，如果Face物件還引用了其他的物件，比如說Mouth，如果不經過處理，Body物件拷貝之後還是會通過一級一級的引用，引用到同一個Mouth物件。同理，如果要讓Body在引用鏈上完全獨立，只能顯式的讓Mouth物件也被拷貝。到此，可以得到如下結論：如果在拷貝一個物件時，要想讓這個拷貝的物件和源物件完全彼此獨立，那麼在引用鏈上的每一級物件都要被顯式的拷貝。所以建立徹底的深拷貝是非常麻煩的，尤其是在引用關係非常複雜的情況下，或者在引用鏈的某一級上引用了一個第三方的物件，而這個物件沒有實現clone方法，那麼在它之後的所有引用的物件都是被共享的。舉例來說，如果被Head引用的Face類是第三方庫中的類，並且沒有實現Cloneable介面，那麼在Face之後的所有物件都會被拷貝前後的兩個Body物件共同引用。假設Face物件內部組合了Mouth物件，並且Mouth物件內部組合了Tooth物件。

clone在平時專案的開發中可能用的不是很頻繁，但是區分深拷貝和淺拷貝會讓我們對java記憶體結構和執行方式有更深的瞭解。至於徹底深拷貝，幾乎是不可能實現的，原因已經在上一節中進行了說明。深拷貝和徹底深拷貝，在建立不可變物件時，可能對程式有著微妙的影響，可能會決定我們建立的不可變物件是不是真的不可變。clone的一個重要的應用也是用於不可變物件的建立。

alibaba的規範手冊

【強制】關於基本資料型別與包裝資料型別的使用標準如下：
1）所有的 POJO 類屬性必須使用包裝資料型別。
2） RPC 方法的返回值和引數必須使用包裝資料型別。
3）所有的區域性變數推薦使用基本資料型別。
說明： POJO 類屬性沒有初值是提醒使用者在需要使用時，必須自己顯式地進行賦值，任何NPE 問題，或者入庫檢查，都由使用者來保證。
正例：資料庫的查詢結果可能是 null，因為自動拆箱，用基本資料型別接收有 NPE 風險。反例：某業務的交易報表上顯示成交總額漲跌情況，即正負 x%， x 為基本資料型別，呼叫的RPC 服務，呼叫不成功時，返回的是預設值，頁面顯示： 0%，這是不合理的，應該顯示成中劃線-。所以包裝資料型別的 null 值，能夠表示額外的資訊，如：遠端呼叫失敗，異常退出。
【推薦】慎用 Object 的 clone 方法來拷貝物件。
說明：物件的 clone 方法預設是淺拷貝，若想實現深拷貝需要重寫 clone 方法實現屬性物件的拷貝。

淺拷貝和深拷貝(談談java中的clone)

引用的拷貝

淺拷貝

深拷貝

真的是深拷貝嗎

如何進行徹底的深拷貝

淺拷貝和深拷貝(談談java中的clone)

初始JAVA中淺拷貝和深拷貝

python中的淺拷貝和深拷貝

java淺拷貝和深拷貝

JavaScript中的淺拷貝和深拷貝

Python 中的淺拷貝和深拷貝

淺談java淺拷貝和深拷貝

java淺拷貝和深拷貝(基礎也是很重要的)

Java: 淺拷貝和深拷貝的理解和實現方式

對java的淺拷貝和深拷貝的理解

C語言中的淺拷貝和深拷貝

JS中的淺拷貝和深拷貝。

JavaScript中淺拷貝和深拷貝，棧堆詳解

理解javascript中淺拷貝和深拷貝

java物件的淺拷貝和深拷貝

java淺拷貝和深拷貝的區別

opencv 中的淺拷貝和深拷貝

Python3中的淺拷貝和深拷貝入門理解

java 淺拷貝和深拷貝物件克隆clone

Python 中的淺拷貝和深拷貝詳解

淺拷貝和深拷貝(談談java中的clone)

引用的拷貝

淺拷貝

深拷貝

真的是深拷貝嗎

如何進行徹底的深拷貝

相關推薦