Java深拷貝與淺拷貝

轉載：http://blog.csdn.net/wangnanwlw/article/details/52300117

一、引言

對象拷貝(Object Copy)就是將一個對象的屬性拷貝到另一個有着相同類類型的對象中去。在程序中拷貝對象是很常見的，主要是爲了在新的上下文環境中複用對象的部分或全部 數據。Java中有三種類型的對象拷貝：淺拷貝(Shallow Copy)、深拷貝(Deep Copy)、延遲拷貝(Lazy Copy)。

二、淺拷貝

• 1、什麼是淺拷貝
  淺拷貝是按位拷貝對象，它會創建一個新對象，這個對象有着原始對象屬性值的一份精確拷貝。如果屬性是基本類型，拷貝的就是基本類型的值；如果屬性是內存地址（引用類型），拷貝的就是內存地址 ，因此如果其中一個對象改變了這個地址，就會影響到另一個對象。
  
  在圖中，SourceObject有一個int類型的屬性 “field1”和一個引用類型屬性”refObj”（引用ContainedObject類型的對象）。當對SourceObject做淺拷貝時，創建了CopiedObject，它有一個包含”field1”拷貝值的屬性”field2”以及仍指向refObj本身的引用。由於”field1”是基本類型，所以只是將它的值拷貝給”field2”，但是由於”refObj”是一個引用類型, 所以CopiedObject指向”refObj”相同的地址。因此對SourceObject中的”refObj”所做的任何改變都會影響到CopiedObject。

• 2、如何實現淺拷貝
  下面是實現淺拷貝的一個例子

public class Subject {
    private String name; 
   public Subject(String s) { 
      name = s; 
   } 
   public String getName() { 
      return name; 
   } 
   public void setName(String s) { 
      name = s; 
   } 
}
public class Student implements Cloneable { 
    // 對象引用 
   private Subject subj; 

   private String name; 

   public Student(String s, String sub) { 
      name = s; 
      subj = new Subject(sub); 
   } 

   public Subject getSubj() { 
      return subj; 
   } 

   public String getName() { 
      return name; 
   } 

   public void setName(String s) { 
      name = s; 
   } 

   /** 
    *  重寫clone()方法 
    * @return 
    */ 
   public Object clone() { 
      //淺拷貝 
      try { 
         // 直接調用父類的clone()方法
         return super.clone(); 
      } catch (CloneNotSupportedException e) { 
         return null; 
      } 
   } 
}

public class CopyTest {

    public static void main(String[] args) {
        // 原始對象
        Student stud = new Student("John", "Algebra");
        System.out.println("原始對象: " + stud.getName() + " - " + stud.getSubj().getName());
        // 拷貝對象
        Student clonedStud = (Student) stud.clone();
        System.out.println("拷貝對象: " + clonedStud.getName() + " - " + clonedStud.getSubj().getName());
        // 原始對象和拷貝對象是否一樣：
        System.out.println("原始對象和拷貝對象是否一樣: " + (stud == clonedStud));
        // 原始對象和拷貝對象的name屬性是否一樣
        System.out.println("原始對象和拷貝對象的name屬性是否一樣: " + (stud.getName() == clonedStud.getName()));
        // 原始對象和拷貝對象的subj屬性是否一樣
        System.out.println("原始對象和拷貝對象的subj屬性是否一樣: " + (stud.getSubj() == clonedStud.getSubj()));
        stud.setName("Dan");
        stud.getSubj().setName("Physics");
        System.out.println("原始對象更新: " + stud.getName() + " - " + stud.getSubj().getName());
        System.out.println("原始對象更新後，淺複製對象變化: " + clonedStud.getName() + " - " + clonedStud.getSubj().getName());
    }
}

打印結果：
原始對象: John - Algebra
拷貝對象: John - Algebra
原始對象和拷貝對象是否一樣: false
原始對象和拷貝對象的name屬性是否一樣: true
原始對象和拷貝對象的subj屬性是否一樣: true
原始對象更新: Dan - Physics
原始對象更新後，淺複製對象變化: John - Physics

在這個例子中，我讓要拷貝的類Student實現了Clonable接口並重寫Object類的clone()方法，然後在方法內部調用super.clone()方法。從輸出結果中我們可以看到，對原始對象stud的”name”屬性所做的改變並沒有影響到拷貝對象clonedStud，但是對引用對象subj的”name”屬性所做的改變影響到了拷貝對象clonedStud。

三、深拷貝

- 1、什麼是深拷貝
深拷貝會拷貝所有的屬性,並拷貝屬性指向的動態分配的內存。當對象和它所引用的對象一起拷貝時即發生深拷貝。深拷貝相比於淺拷貝速度較慢並且花銷較大。
在上圖中，SourceObject有一個int類型的屬性 “field1”和一個引用類型屬性”refObj1”（引用ContainedObject類型的對象）。當對SourceObject做深拷貝時，創建了CopiedObject，它有一個包含”field1”拷貝值的屬性”field2”以及包含”refObj1”拷貝值的引用類型屬性”refObj2” 。因此對SourceObject中的”refObj”所做的任何改變都不會影響到CopiedObject

• 2、如何實現深拷貝
  下面是實現深拷貝的一個例子。只是在淺拷貝的例子上做了一點小改動，Subject 和CopyTest 類都沒有變化。

public class Subject {
    private String name; 
   public Subject(String s) { 
      name = s; 
   } 
   public String getName() { 
      return name; 
   } 
   public void setName(String s) { 
      name = s; 
   } 
}
public class Student implements Cloneable { 
    // 對象引用 
   private Subject subj; 

   private String name; 

   public Student(String s, String sub) { 
      name = s; 
      subj = new Subject(sub); 
   } 

   public Subject getSubj() { 
      return subj; 
   } 

   public String getName() { 
      return name; 
   } 

   public void setName(String s) { 
      name = s; 
   } 

   /** 
    *  重寫clone()方法 
    * @return 
    */ 
   public Object clone() { 
      //淺拷貝 
      try { 
         // 直接調用父類的clone()方法
         return super.clone(); 
      } catch (CloneNotSupportedException e) { 
         return null; 
      } 
   } 
}

public class CopyTest {

    public static void main(String[] args) {
        // 原始對象
        Student stud = new Student("John", "Algebra");
        System.out.println("原始對象: " + stud.getName() + " - " + stud.getSubj().getName());
        // 拷貝對象
        Student clonedStud = (Student) stud.clone();
        System.out.println("拷貝對象: " + clonedStud.getName() + " - " + clonedStud.getSubj().getName());
        // 原始對象和拷貝對象是否一樣：
        System.out.println("原始對象和拷貝對象是否一樣: " + (stud == clonedStud));
        // 原始對象和拷貝對象的name屬性是否一樣
        System.out.println("原始對象和拷貝對象的name屬性是否一樣: " + (stud.getName() == clonedStud.getName()));
        // 原始對象和拷貝對象的subj屬性是否一樣
        System.out.println("原始對象和拷貝對象的subj屬性是否一樣: " + (stud.getSubj() == clonedStud.getSubj()));
        stud.setName("Dan");
        stud.getSubj().setName("Physics");
        System.out.println("原始對象更新: " + stud.getName() + " - " + stud.getSubj().getName());
        System.out.println("原始對象更新後，淺複製對象變化: " + clonedStud.getName() + " - " + clonedStud.getSubj().getName());
    }

}

打印結果：
原始對象: John - Algebra
拷貝對象: John - Algebra
原始對象和拷貝對象是否一樣: false
原始對象和拷貝對象的name屬性是否一樣: true
原始對象和拷貝對象的subj屬性是否一樣: false
原始對象更新: Dan - Physics
原始對象更新後，淺複製對象變化: John - Algebra

很容易發現clone()方法中的一點變化。因爲它是深拷貝，所以你需要創建拷貝類的一個對象。因爲在Student類中有對象引用，所以需要在Student類中實現Cloneable接口並且重寫clone方法。

如何選擇：
如果對象的屬性全是基本類型的，那麼可以使用淺拷貝，但是如果對象有引用屬性，那就要基於具體的需求來選擇淺拷貝還是深拷貝。我的意思是如果對象引用任何時候都不會被改變，那麼沒必要使用深拷貝，只需要使用淺拷貝就行了。如果對象引用經常改變，那麼就要使用深拷貝。沒有一成不變的規則，一切都取決於具體需求。

通過序列化實現深拷貝：
也可以通過序列化來實現深拷貝。序列化是幹什麼的?它將整個對象圖寫入到一個持久化存儲文件中並且當需要的時候把它讀取回來, 這意味着當你需要把它讀取回來時你需要整個對象圖的一個拷貝。這就是當你深拷貝一個對象時真正需要的東西。請注意，當你通過序列化進行深拷貝時，必須確保對象圖中所有類都是可序列化的。
注意，序列化這種方式有其自身的限制和問題：
因爲無法序列化transient變量, 使用這種方法將無法拷貝transient變量。
再就是性能問題。創建一個socket, 序列化一個對象, 通過socket傳輸它, 然後反序列化它，這個過程與調用已有對象的方法相比是很慢的。所以在性能上會有天壤之別。如果性能對你的代碼來說是至關重要的，建議不要使用這種方式。它比通過實現Clonable接口這種方式來進行深拷貝幾乎多花100倍的時間。