歡迎光臨
每天分享高質量文章

深入淺出Java中的clone克隆方法,寫得太棒了!

作者:張紀剛

blog.csdn.net/zhangjg_blog/article/details/18369201/

Java中物件的創建

clone 顧名思義就是 複製 , 在Java語言中, clone方法被物件呼叫,所以會複製物件。所謂的複製物件,首先要分配一個和源物件同樣大小的空間,在這個空間中創建一個新的物件。

我們回顧一下:在java語言中,有幾種方式可以創建物件呢?

  1. 使用new運算子創建一個物件
  2. 使用clone方法複製一個物件

那麼這兩種方式有什麼相同和不同呢?

new運算子的本意是分配記憶體。程式執行到new運算子時, 首先去看new運算子後面的型別,因為知道了型別,才能知道要分配多大的記憶體空間。分配完記憶體之後,再呼叫建構式,填充物件的各個域,這一步叫做物件的初始化,構造方法傳回後,一個物件創建完畢,可以把他的取用(地址)發佈到外部,在外部就可以使用這個取用操縱這個物件。

clone在第一步是和new相似的, 都是分配記憶體,呼叫clone方法時,分配的記憶體和源物件(即呼叫clone方法的物件)相同,然後再使用原物件中對應的各個域,填充新物件的域, 填充完成之後,clone方法傳回,一個新的相同的物件被創建,同樣可以把這個新物件的取用發佈到外部 。

複製物件 or 複製取用

在Java中,以下類似的代碼非常常見:

  1. 1. Person p = new Person(23, "zhang");  
  2.  
  3. 2. Person p1 = p;
  4.  
  5. 4. System.out.println(p);  
  6.  
  7. 5. System.out.println(p1);  

打印結果:

  1. 1. com.pansoft.zhangjg.testclone.[email protected]
  2. 2. com.pansoft.zhangjg.testclone.[email protected]

可以看出,打印的地址值是相同的,既然地址都是相同的,那麼肯定是同一個物件。p和p1只是取用而已,他們都指向了一個相同的物件Person(23, “zhang”) 。 可以把這種現象叫做 取用的複製 。

上面代碼執行完成之後, 記憶體中的情景如下圖所示:

而下麵的代碼是真真正正的克隆了一個物件:

  1. 1. Person p = new Person(23, "zhang");  
  2.  
  3. 2. Person p1 = (Person) p.clone();  
  4.  
  5. 4. System.out.println(p);  
  6.  
  7. 5. System.out.println(p1);

打印結果:

  1. 1. com.pansoft.zhangjg.testclone.[email protected]
  2.  
  3. 2. com.pansoft.zhangjg.testclone.[email protected]

以上代碼執行完成後, 記憶體中的情景如下圖所示:

深拷貝 or 淺拷貝

上面的示例代碼中,Person中有兩個成員變數,分別是name和age, name是String型別, age是int型別。代碼非常簡單,如下所示:

  1. 1. public class Person implements Cloneable{  
  2.  
  3. 3.    private int age ;
  4.  
  5. 4.    private String name;
  6.  
  7. 6.    public Person(int age, String name) {
  8.  
  9. 7.        this.age = age;  
  10.  
  11. 8.        this.name = name;  
  12.  
  13. 9.    }  
  14.  
  15. 11.    public Person() {}  
  16.  
  17. 13.    public int getAge() {
  18.  
  19. 14.        return age;
  20.  
  21. 15.    }  
  22.  
  23. 17.    public String getName() {
  24.  
  25. 18.        return name;
  26.  
  27. 19.    }  
  28.  
  29. 21. @Override
  30.  
  31. 22.    protected Object clone() throws CloneNotSupportedException {
  32.  
  33. 23.        return (Person)super.clone();  
  34.  
  35. 24.    }  
  36.  
  37. 25. }  

由於age是基本資料型別, 那麼對它的拷貝沒有什麼疑議,直接將一個4位元組的整數值拷貝過來就行。但是name是String型別的, 它只是一個取用, 指向一個真正的String物件,那麼對它的拷貝有兩種方式:

①直接將源物件中的name的取用值拷貝給新物件的name欄位;

②根據原Person物件中的name指向的字串物件創建一個新的相同的字串物件,將這個新字串物件的取用賦給新拷貝的Person物件的name欄位。

這兩種拷貝方式分別叫做 淺拷貝 和 深拷貝 。

深拷貝和淺拷貝的原理如下圖所示:

下麵通過代碼進行驗證。推薦閱讀:Java 中的 String 真的是不可變的嗎?

如果兩個Person物件的name的地址值相同, 說明兩個物件的name都指向同一個String物件, 也就是淺拷貝, 而如果兩個物件的name的地址值不同, 那麼就說明指向不同的String物件, 也就是在拷貝Person物件的時候, 同時拷貝了name取用的String物件, 也就是深拷貝。驗證代碼如下:

  1. 1. Person p = new Person(23, "zhang");  
  2.  
  3. 2. Person p1 = (Person) p.clone();  
  4.  
  5. 4. String result = p.getName() == p1.getName()
  6.  
  7. 5. ? "clone是淺拷貝的" : "clone是深拷貝的";  
  8.  
  9. 7. System.out.println(result);  

打印結果:

  1. clone是淺拷貝的

所以,clone方法執行的是淺拷貝, 在編寫程式時要註意這個細節。

如果想要實現深拷貝,可以通過改寫Object中的clone方法的方式。

現在為了要在clone物件時進行深拷貝, 那麼就要Clonable接口,改寫並實現clone方法,除了呼叫父類中的clone方法得到新的物件, 還要將該類中的取用變數也clone出來。如果只是用Object中預設的clone方法,是淺拷貝的,再次以下麵的代碼驗證:

  1. 1. static class Body implements Cloneable{  
  2.  
  3. 2.    public Head head;
  4.  
  5. 4.    public Body() {}  
  6.  
  7. 6.    public Body(Head head) {this.head = head;}  
  8.  
  9. 8. @Override
  10.  
  11. 9.    protected Object clone() throws CloneNotSupportedException {
  12.  
  13. 10.        return super.clone();  
  14.  
  15. 11.    }  
  16.  
  17. 13. }  
  18.  
  19. 14. static class Head /*implements Cloneable*/{  
  20.  
  21. 15.    public Face face;
  22.  
  23. 17.    public Head() {}  
  24.  
  25. 18.    public Head(Face face){this.face = face;}  
  26.  
  27. 20. }  
  28.  
  29. 21. public static void main(String[] args) throws CloneNotSupportedException {
  30.  
  31. 23.    Body body = new Body(new Head());  
  32.  
  33. 25.    Body body1 = (Body) body.clone();  
  34.  
  35. 27.    System.out.println("body == body1 : " + (body == body1) );
  36.  
  37. 29.    System.out.println("body.head == body1.head : " +  (body.head == body1.head));
  38.  
  39. 32. }  

在以上代碼中, 有兩個主要的類, 分別為Body和Face, 在Body類中, 組合了一個Face物件。當對Body物件進行clone時, 它組合的Face物件只進行淺拷貝。打印結果可以驗證該結論:

  1. 1. body == body1 : false
  2.  
  3. 2. body.head == body1.head : true

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

  1. 1. static class Body implements Cloneable{  
  2.  
  3. 2.    public Head head;
  4.  
  5. 3.    public Body() {}  
  6.  
  7. 4.    public Body(Head head) {this.head = head;}  
  8.  
  9. 6. @Override
  10.  
  11. 7.    protected Object clone() throws CloneNotSupportedException {
  12.  
  13. 8.        Body newBody =  (Body) super.clone();  
  14.  
  15. 9.        newBody.head = (Head) head.clone();  
  16.  
  17. 10.        return newBody;
  18.  
  19. 11.    }  
  20.  
  21. 13. }  
  22.  
  23. 14. static class Head implements Cloneable{  
  24.  
  25. 15.    public Face face;
  26.  
  27. 17.    public Head() {}  
  28.  
  29. 18.    public Head(Face face){this.face = face;}  
  30.  
  31. 19. @Override
  32.  
  33. 20.    protected Object clone() throws CloneNotSupportedException {
  34.  
  35. 21.        return super.clone();  
  36.  
  37. 22.    }  
  38.  
  39. 23. }  
  40.  
  41. 24. public static void main(String[] args) throws CloneNotSupportedException {
  42.  
  43. 26.    Body body = new Body(new Head());  
  44.  
  45. 28.    Body body1 = (Body) body.clone();  
  46.  
  47. 30.    System.out.println("body == body1 : " + (body == body1) );
  48.  
  49. 32.    System.out.println("body.head == body1.head : " +  (body.head == body1.head));
  50.  
  51. 35. }  

打印結果:

  1. 1. body == body1 : false
  2.  
  3. 2. 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類的代碼就可以了, 但是為了閱讀起來具有連貫性,避免丟失背景關係信息, 還是給出整個程式,整個程式也非常簡短)

  1. 1. static class Body implements Cloneable{  
  2.  
  3. 2.    public Head head;
  4.  
  5. 3.    public Body() {}  
  6.  
  7. 4.    public Body(Head head) {this.head = head;}  
  8.  
  9. 6. @Override
  10.  
  11. 7.    protected Object clone() throws CloneNotSupportedException {
  12.  
  13. 8.        Body newBody =  (Body) super.clone();  
  14.  
  15. 9.        newBody.head = (Head) head.clone();  
  16.  
  17. 10.        return newBody;
  18.  
  19. 11.    }  
  20.  
  21. 13. }  
  22.  
  23. 15. static class Head implements Cloneable{  
  24.  
  25. 16.    public Face face;
  26.  
  27. 18.    public Head() {}  
  28.  
  29. 19.    public Head(Face face){this.face = face;}  
  30.  
  31. 20. @Override
  32.  
  33. 21.    protected Object clone() throws CloneNotSupportedException {
  34.  
  35. 22.        return super.clone();  
  36.  
  37. 23.    }  
  38.  
  39. 24. }  
  40.  
  41. 26. static class Face{}  
  42.  
  43. 28. public static void main(String[] args) throws CloneNotSupportedException {
  44.  
  45. 30.    Body body = new Body(new Head(new Face()));  
  46.  
  47. 32.    Body body1 = (Body) body.clone();  
  48.  
  49. 34.    System.out.println("body == body1 : " + (body == body1) );
  50.  
  51. 36.    System.out.println("body.head == body1.head : " +  (body.head == body1.head));
  52.  
  53. 38.    System.out.println("body.head.face == body1.head.face : " +  (body.head.face == body1.head.face));
  54.  
  55. 41. }  

打印結果:

  1. 1. body == body1 : false
  2.  
  3. 2. body.head == body1.head : false
  4.  
  5. 3. 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物件。修改的部分代碼如下:

  1. 1. static class Head implements Cloneable{  
  2.  
  3. 2.    public Face face;
  4.  
  5. 4.    public Head() {}  
  6.  
  7. 5.    public Head(Face face){this.face = face;}  
  8.  
  9. 6. @Override
  10.  
  11. 7.    protected Object clone() throws CloneNotSupportedException {
  12.  
  13. 8.        //return super.clone();  
  14.  
  15. 9.        Head newHead = (Head) super.clone();  
  16.  
  17. 10.        newHead.face = (Face) this.face.clone();  
  18.  
  19. 11.        return newHead;
  20.  
  21. 12.    }  
  22.  
  23. 13. }  
  24.  
  25. 15. static class Face implements Cloneable{  
  26.  
  27. 16. @Override
  28.  
  29. 17.    protected Object clone() throws CloneNotSupportedException {
  30.  
  31. 18.        return super.clone();  
  32.  
  33. 19.    }  
  34.  
  35. 20. }  

再次運行上面的示例,得到的運行結果如下:

  1. 1. body == body1 : false
  2.  
  3. 2. body.head == body1.head : false
  4.  
  5. 3. 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的一個重要的應用也是用於不可變物件的創建。關於創建不可變物件,我會在後續的文章中進行闡述,敬請期待。

赞(0)

分享創造快樂