快捷導(dǎo)航

Java中的深拷貝和淺拷貝介紹

更新時(shí)間：2014年03月17日 18:08:17 作者：

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

一、引言
對象拷貝(Object Copy)就是將一個(gè)對象的屬性拷貝到另一個(gè)有著相同類類型的對象中去。在程序中拷貝對象是很常見的，主要是為了在新的上下文環(huán)境中復(fù)用對象的部分或全部數(shù)據(jù)。Java中有三種類型的對象拷貝：淺拷貝(Shallow Copy)、深拷貝(Deep Copy)、延遲拷貝(Lazy Copy)。

二、淺拷貝

1、什么是淺拷貝
淺拷貝是按位拷貝對象，它會(huì)創(chuàng)建一個(gè)新對象，這個(gè)對象有著原始對象屬性值的一份精確拷貝。如果屬性是基本類型，拷貝的就是基本類型的值；如果屬性是內(nèi)存地址（引用類型），拷貝的就是內(nèi)存地址，因此如果其中一個(gè)對象改變了這個(gè)地址，就會(huì)影響到另一個(gè)對象。

在圖中，SourceObject有一個(gè)int類型的屬性 "field1"和一個(gè)引用類型屬性"refObj"（引用ContainedObject類型的對象）。當(dāng)對SourceObject做淺拷貝時(shí)，創(chuàng)建了CopiedObject，它有一個(gè)包含"field1"拷貝值的屬性"field2"以及仍指向refObj本身的引用。由于"field1"是基本類型，所以只是將它的值拷貝給"field2"，但是由于"refObj"是一個(gè)引用類型, 所以CopiedObject指向"refObj"相同的地址。因此對SourceObject中的"refObj"所做的任何改變都會(huì)影響到CopiedObject。

2、如何實(shí)現(xiàn)淺拷貝

下面是實(shí)現(xiàn)淺拷貝的一個(gè)例子

復(fù)制代碼代碼如下:

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 { 
         // 直接調(diào)用父類的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("Original Object: " + stud.getName() + " - " + stud.getSubj().getName());
        // 拷貝對象
        Student clonedStud = (Student) stud.clone();
        System.out.println("Cloned Object: " + clonedStud.getName() + " - " + clonedStud.getSubj().getName());
        // 原始對象和拷貝對象是否一樣：
        System.out.println("Is Original Object the same with Cloned Object: " + (stud == clonedStud));
        // 原始對象和拷貝對象的name屬性是否一樣
        System.out.println("Is Original Object's field name the same with Cloned Object: " +
     (stud.getName() == clonedStud.getName()));
        // 原始對象和拷貝對象的subj屬性是否一樣
        System.out.println("Is Original Object's field subj the same with Cloned Object: " +
    (stud.getSubj() == clonedStud.getSubj()));
        stud.setName("Dan");
        stud.getSubj().setName("Physics");
        System.out.println("Original Object after it is updated: " + stud.getName() + " - " +
     stud.getSubj().getName());
        System.out.println("Cloned Object after updating original object: " + clonedStud.getName() +
     " - " + clonedStud.getSubj().getName());
    }
}

輸出結(jié)果如下：
Original Object: John - Algebra
Cloned Object: John - Algebra
Is Original Object the same with Cloned Object: false
Is Original Object's field name the same with Cloned Object: true
Is Original Object's field subj the same with Cloned Object: true
Original Object after it is updated: Dan - Physics
Cloned Object after updating original object: John - Physics

在這個(gè)例子中，我讓要拷貝的類Student實(shí)現(xiàn)了Clonable接口并重寫Object類的clone()方法，然后在方法內(nèi)部調(diào)用super.clone()方法。從輸出結(jié)果中我們可以看到，對原始對象stud的"name"屬性所做的改變并沒有影響到拷貝對象clonedStud，但是對引用對象subj的"name"屬性所做的改變影響到了拷貝對象clonedStud。

三、深拷貝
1、什么是深拷貝
深拷貝會(huì)拷貝所有的屬性,并拷貝屬性指向的動(dòng)態(tài)分配的內(nèi)存。當(dāng)對象和它所引用的對象一起拷貝時(shí)即發(fā)生深拷貝。深拷貝相比于淺拷貝速度較慢并且花銷較大。

在上圖中，SourceObject有一個(gè)int類型的屬性 "field1"和一個(gè)引用類型屬性"refObj1"（引用ContainedObject類型的對象）。當(dāng)對SourceObject做深拷貝時(shí)，創(chuàng)建了CopiedObject，它有一個(gè)包含"field1"拷貝值的屬性"field2"以及包含"refObj1"拷貝值的引用類型屬性"refObj2" 。因此對SourceObject中的"refObj"所做的任何改變都不會(huì)影響到CopiedObject

2、如何實(shí)現(xiàn)深拷貝
下面是實(shí)現(xiàn)深拷貝的一個(gè)例子。只是在淺拷貝的例子上做了一點(diǎn)小改動(dòng)，Subject 和CopyTest 類都沒有變化。

復(fù)制代碼代碼如下:

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() { 
      // 深拷貝，創(chuàng)建拷貝類的一個(gè)新對象，這樣就和原始對象相互獨(dú)立
      Student s = new Student(name, subj.getName()); 
      return s; 
   } 
}

輸出結(jié)果如下：
Original Object: John - Algebra
Cloned Object: John - Algebra
Is Original Object the same with Cloned Object: false
Is Original Object's field name the same with Cloned Object: true
Is Original Object's field subj the same with Cloned Object: false
Original Object after it is updated: Dan - Physics
Cloned Object after updating original object: John - Algebra

很容易發(fā)現(xiàn)clone()方法中的一點(diǎn)變化。因?yàn)樗巧羁截?，所以你需要?jiǎng)?chuàng)建拷貝類的一個(gè)對象。因?yàn)樵赟tudent類中有對象引用，所以需要在Student類中實(shí)現(xiàn)Cloneable接口并且重寫clone方法。

3、通過序列化實(shí)現(xiàn)深拷貝
也可以通過序列化來實(shí)現(xiàn)深拷貝。序列化是干什么的?它將整個(gè)對象圖寫入到一個(gè)持久化存儲(chǔ)文件中并且當(dāng)需要的時(shí)候把它讀取回來, 這意味著當(dāng)你需要把它讀取回來時(shí)你需要整個(gè)對象圖的一個(gè)拷貝。這就是當(dāng)你深拷貝一個(gè)對象時(shí)真正需要的東西。請注意，當(dāng)你通過序列化進(jìn)行深拷貝時(shí)，必須確保對象圖中所有類都是可序列化的。

復(fù)制代碼代碼如下:

public class ColoredCircle implements Serializable { 
   private int x; 
   private int y; 

   public ColoredCircle(int x, int y) { 
      this.x = x; 
      this.y = y; 
   } 

   public int getX() { 
      return x; 
   } 

   public void setX(int x) { 
      this.x = x; 
   } 

   public int getY() { 
      return y; 
   } 

   public void setY(int y) { 
      this.y = y; 
   } 

   @Override 
   public String toString() { 
      return "x=" + x + ", y=" + y; 
   } 
}
public class DeepCopy {

   public static void main(String[] args) throws IOException { 
      ObjectOutputStream oos = null; 
      ObjectInputStream ois = null; 

      try { 
         // 創(chuàng)建原始的可序列化對象 
         ColoredCircle c1 = new ColoredCircle(100, 100); 
         System.out.println("Original = " + c1); 

         ColoredCircle c2 = null; 

         // 通過序列化實(shí)現(xiàn)深拷貝 
         ByteArrayOutputStream bos = new ByteArrayOutputStream(); 
         oos = new ObjectOutputStream(bos); 
         // 序列化以及傳遞這個(gè)對象 
         oos.writeObject(c1); 
         oos.flush(); 
         ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray()); 
         ois = new ObjectInputStream(bin); 
         // 返回新的對象 
         c2 = (ColoredCircle) ois.readObject(); 

         // 校驗(yàn)內(nèi)容是否相同 
         System.out.println("Copied   = " + c2); 
         // 改變原始對象的內(nèi)容 
         c1.setX(200); 
         c1.setY(200); 
         // 查看每一個(gè)現(xiàn)在的內(nèi)容 
         System.out.println("Original = " + c1); 
         System.out.println("Copied   = " + c2); 
      } catch (Exception e) { 
         System.out.println("Exception in main = " + e); 
      } finally { 
         oos.close(); 
         ois.close(); 
      } 
   } 
}

輸出結(jié)果如下：
Original = x=100, y=100
Copied = x=100, y=100
Original = x=200, y=200
Copied = x=100, y=100
這里，你只需要做以下幾件事兒:
(1)確保對象圖中的所有類都是可序列化的
(2)創(chuàng)建輸入輸出流
(3)使用這個(gè)輸入輸出流來創(chuàng)建對象輸入和對象輸出流
(4)將你想要拷貝的對象傳遞給對象輸出流
(5)從對象輸入流中讀取新的對象并且轉(zhuǎn)換回你所發(fā)送的對象的類

在這個(gè)例子中，我創(chuàng)建了一個(gè)ColoredCircle對象c1然后將它序列化 (將它寫到ByteArrayOutputStream中). 然后我反序列化這個(gè)序列化后的對象并將它保存到c2中。隨后我修改了原始對象c1。然后結(jié)果如你所見，c1不同于c2，對c1所做的任何修改都不會(huì)影響c2。

注意，序列化這種方式有其自身的限制和問題：
因?yàn)闊o法序列化transient變量, 使用這種方法將無法拷貝transient變量。

再就是性能問題。創(chuàng)建一個(gè)socket, 序列化一個(gè)對象, 通過socket傳輸它, 然后反序列化它，這個(gè)過程與調(diào)用已有對象的方法相比是很慢的。所以在性能上會(huì)有天壤之別。如果性能對你的代碼來說是至關(guān)重要的，建議不要使用這種方式。它比通過實(shí)現(xiàn)Clonable接口這種方式來進(jìn)行深拷貝幾乎多花100倍的時(shí)間。

四、延遲拷貝
延遲拷貝是淺拷貝和深拷貝的一個(gè)組合，實(shí)際上很少會(huì)使用。當(dāng)最開始拷貝一個(gè)對象時(shí)，會(huì)使用速度較快的淺拷貝，還會(huì)使用一個(gè)計(jì)數(shù)器來記錄有多少對象共享這個(gè)數(shù)據(jù)。當(dāng)程序想要修改原始的對象時(shí)，它會(huì)決定數(shù)據(jù)是否被共享（通過檢查計(jì)數(shù)器）并根據(jù)需要進(jìn)行深拷貝。
延遲拷貝從外面看起來就是深拷貝，但是只要有可能它就會(huì)利用淺拷貝的速度。當(dāng)原始對象中的引用不經(jīng)常改變的時(shí)候可以使用延遲拷貝。由于存在計(jì)數(shù)器，效率下降很高，但只是常量級(jí)的開銷。而且, 在某些情況下, 循環(huán)引用會(huì)導(dǎo)致一些問題。

五、如何選擇
如果對象的屬性全是基本類型的，那么可以使用淺拷貝，但是如果對象有引用屬性，那就要基于具體的需求來選擇淺拷貝還是深拷貝。我的意思是如果對象引用任何時(shí)候都不會(huì)被改變，那么沒必要使用深拷貝，只需要使用淺拷貝就行了。如果對象引用經(jīng)常改變，那么就要使用深拷貝。沒有一成不變的規(guī)則，一切都取決于具體需求。

您可能感興趣的文章: