深刻淺出Java中的clone克隆方法，寫得太棒了！

時間  2020-04-24
標籤 深刻 java clone 克隆 方法 寫得 棒了 欄目 Java 简体版
原文   原文鏈接
做者：張紀剛
blog.csdn.net/zhangjg_blog/article/details/18369201/
2019-03-24 10:33:04

Java中對象的建立

clone 顧名思義就是 複製 ， 在Java語言中， clone方法被對象調用，因此會複製對象。所謂的複製對象，首先要分配一個和源對象一樣大小的空間，在這個空間中建立一個新的對象。java

咱們回顧一下：在java語言中，有幾種方式能夠建立對象呢？面試

  1. 使用new操做符建立一個對象
  2. 使用clone方法複製一個對象

那麼這兩種方式有什麼相同和不一樣呢？後端

new操做符的本意是分配內存。程序執行到new操做符時， 首先去看new操做符後面的類型，由於知道了類型，才能知道要分配多大的內存空間。分配完內存以後，再調用構造函數，填充對象的各個域，這一步叫作對象的初始化，構造方法返回後，一個對象建立完畢，能夠把他的引用（地址）發佈到外部，在外部就可使用這個引用操縱這個對象。微信

而clone在第一步是和new類似的， 都是分配內存，調用clone方法時，分配的內存和源對象（即調用clone方法的對象）相同，而後再使用原對象中對應的各個域，填充新對象的域， 填充完成以後，clone方法返回，一個新的相同的對象被建立，一樣能夠把這個新對象的引用發佈到外部 。多線程

複製對象 or 複製引用

在Java中，如下相似的代碼很是常見：架構

Person p = new Person(23, "zhang");
Person p1 = p;
System.out.println(p);
System.out.println(p1);

打印結果：ide

com.pansoft.zhangjg.testclone.Person@2f9ee1accom.pansoft.zhangjg.testclone.Person@2f9ee1ac

能夠看出，打印的地址值是相同的，既然地址都是相同的，那麼確定是同一個對象。p和p1只是引用而已，他們都指向了一個相同的對象Person(23, "zhang") 。 能夠把這種現象叫作 引用的複製 。函數

上面代碼執行完成以後， 內存中的情景以下圖所示：工具

而下面的代碼是真真正正的克隆了一個對象：this

Person p = new Person(23, "zhang");
Person p1 = (Person) p.clone();
System.out.println(p);
System.out.println(p1);

打印結果:

com.pansoft.zhangjg.testclone.Person@2f9ee1accom.pansoft.zhangjg.testclone.Person@67f1fba0

以上代碼執行完成後， 內存中的情景以下圖所示：

深拷貝 or 淺拷貝

上面的示例代碼中，Person中有兩個成員變量，分別是name和age， name是String類型， age是int類型。代碼很是簡單，以下所示：

public  class  Person  implements  Cloneable
{
    private  int  age ;
    private  String  name;
    public  Person(int  age,  String  name)
    {
        this.age  =  age;
        this.name  =  name;
    }
    public  Person()
    {}
    public  int  getAge()
    {
        return  age;
    }
    public  String  getName()
    {
        return  name;
    }      @
    Override       protected  Object  clone()  throws  CloneNotSupportedException
    {
        return (Person) super.clone();
    }
}

因爲age是基本數據類型， 那麼對它的拷貝沒有什麼疑議，直接將一個4字節的整數值拷貝過來就行。可是name是String類型的， 它只是一個引用， 指向一個真正的String對象，那麼對它的拷貝有兩種方式：

①直接將源對象中的name的引用值拷貝給新對象的name字段；

②根據原Person對象中的name指向的字符串對象建立一個新的相同的字符串對象，將這個新字符串對象的引用賦給新拷貝的Person對象的name字段。

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

深拷貝和淺拷貝的原理以下圖所示：

下面經過代碼進行驗證。推薦閱讀：Java 中的 String 真的是不可變的嗎？

若是兩個Person對象的name的地址值相同， 說明兩個對象的name都指向同一個String對象， 也就是淺拷貝， 而若是兩個對象的name的地址值不一樣， 那麼就說明指向不一樣的String對象， 也就是在拷貝Person對象的時候， 同時拷貝了name引用的String對象， 也就是深拷貝。驗證代碼以下：

Person  p  =  new  Person(23,  "zhang");
Person  p1  =   (Person)  p.clone();
String  result  =  p.getName()  ==  p1.getName()            ?  "clone是淺拷貝的"  :  "clone是深拷貝的";
System.out.println(result);

打印結果:

clone是淺拷貝的

因此，clone方法執行的是淺拷貝， 在編寫程序時要注意這個細節。

若是想要實現深拷貝，能夠經過覆蓋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 : falsebody.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 : falsebody.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 : falsebody.head == body1.head : falsebody.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 : falsebody.head == body1.head : falsebody.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的一個重要的應用也是用於不可變對象的建立。關於建立不可變對象，我會在後續的文章中進行闡述，敬請期待。

關注Java技術棧微信公衆號，在後臺回覆關鍵字：_Java_，能夠獲取更多棧長整理的 Java 系列技術乾貨。

推薦去個人博客閱讀更多：

1.Java JVM、集合、多線程、新特性系列教程

2.Spring MVC、Spring Boot、Spring Cloud 系列教程

3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程

4.Java、後端、架構、阿里巴巴等大廠最新面試題

以爲不錯，別忘了點贊+轉發哦！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程