Java中的clone方法-理解淺拷貝和深拷貝

最近學到Java虛擬機的相關知識，更加能理解clone方法的機制了

java中的我們常常需要復制的類型有三種：

1：8種基本類型，如int，long，float等；

2：復合數據類型（數組）；

3：對象變量。

基本數據類型存放在棧中；而對象實例和數組都在堆上分配。

對於基本數據類型我們不需要考慮淺拷貝和深拷貝，使用等號便可復制值。

對於復合數據類型使用等號淺拷貝，僅復制該字段值，如數組則復制地址。。對復合類型使用clone（）方法或者System.arrayCopy進行深拷貝（拷貝復合類型對象的時候，會為其重新創建對象）。

int num1=2;
int num2=num1;
num2=4;
System.out.println(num1==num2);
int[] a={2,1,4,3,5};
int[] b=a;
b[0]=8;
System.out.println(a==b);
int[] c={2,1,4,3,5};
int[] d=c.clone();
d[0]=8;
System.out.println(c==d);

則上述輸出為

false

true 

false 

而對於對象變量，使用clone()僅能實現淺拷貝（僅復制對象的在棧中的reference），下面文章具體對對象變量的兩種克隆進行分析。

 

clone顧名思義就是復制， 在Java語言中， clone方法被對象調用，所以會復制對象。所謂的復制對象，首先要分配一個和源對象同樣大小的空間，在這個空間中創建一個新的對象。

復制對象 or 復制引用

在Java中，以下類似的代碼非常常見：

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

　　

當Person p1 = p;執行之后， 是創建了一個新的對象嗎？ 首先看打印結果：

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

 

可已看出，打印的地址值是相同的，既然地址都是相同的，那么肯定是同一個對象。p和p1只是引用而已，他們都指向了一個相同的對象Person(23, "zhang") 。 可以把這種現象叫做引用的復制。上面代碼執行完成之后， 內存中的情景如下圖所示： 

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

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

　　

從打印結果可以看出，兩個對象的地址是不同的，也就是說創建了新的對象， 而不是把原對象的地址賦給了一個新的引用變量：

com.pansoft.zhangjg.testclone.Person@2f9ee1ac
com.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字段。這兩種拷貝方式分別叫做淺拷貝和深拷貝。深拷貝和淺拷貝的原理如下圖所示：

 

下面通過代碼進行驗證。如果兩個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 : 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();  
    }  
}  

寫在最后

 

clone在平時項目的開發中可能用的不是很頻繁，但是區分深拷貝和淺拷貝會讓我們對java內存結構和運行方式有更深的了解。至於徹底深拷貝，幾乎是不可能實現的。深拷貝和徹底深拷貝，在創建不可變對象時，可能對程序有着微妙的影響，可能會決定我們創建的不可變對象是不是真的不可變。clone的一個重要的應用也是用於不可變對象的創建。

 

本文轉至 http://blog.csdn.net/zhangjg_blog/article/details/18369201/