基于序列化存取實(shí)現(xiàn)java對(duì)象深度克隆的方法詳解

更新時(shí)間：2013年05月17日 10:19:09 作者：

本篇文章是對(duì)序列化存取實(shí)現(xiàn)java對(duì)象深度克隆的方法進(jìn)行了詳細(xì)的分析介紹，需要的朋友參考下

我們知道，在java中，將一個(gè)非原型類型類型的對(duì)象引用，賦值給另一個(gè)對(duì)象的引用之后，這兩個(gè)引用就指向了同一個(gè)對(duì)象，如：

public class DeepCloneTest {

 private class CloneTest {
  private Long myLong = new Long(1);
 }

 public static void main(String args[]) {
  new DeepCloneTest().Test();
 }

 public void Test() {
  CloneTest ct1 = new CloneTest();
  CloneTest ct2 = ct1;

  // to see if ct1 and ct2 are one same reference.
  System.out.println("ct1: " + ct1);
  System.out.println("ct2: " + ct2);

  // if ct1 and ct2 point to one same object, then ct1.myLong == ct2.myLong.
  System.out.println("ct1.myLong: " + ct1.myLong);
  System.out.println("ct2.myLong: " + ct2.myLong);

  // we change ct2's myLong
  ct2.myLong = 2L;

  // to see whether ct1's myLong was changed.
  System.out.println("ct1.myLong: " + ct1.myLong);
  System.out.println("ct2.myLong: " + ct2.myLong);
 }
}

out put：
ct1: DeepCloneTest$CloneTest@c17164
ct2: DeepCloneTest$CloneTest@c17164
ct1.myLong: 1
ct2.myLong: 1
ct1.myLong: 2
ct2.myLong: 2
這個(gè)很easy，估計(jì)學(xué)java的都知道（不知道的是學(xué)java的么？）。
在內(nèi)存中，對(duì)象的引用存放在棧中，對(duì)象的數(shù)據(jù)，存放在堆中，棧中的引用指向了堆中的對(duì)象。這里就是兩個(gè)棧中的引用，指向了堆中的同一個(gè)對(duì)象，所以，當(dāng)改變了 ct2 的 myLong，可以看到，ct1 的 myLong 值也隨之改變，如果用圖來表示，就很容易理解了：

左邊的是棧區(qū)，該區(qū)中有兩個(gè)引用，值相同，它們指向了右邊堆區(qū)的同一個(gè)對(duì)象。
大多時(shí)候，我們會(huì)用 java 語言的這一特性做我們想做的事情，比如，將對(duì)象的引用作為入?yún)魅胍粋€(gè)方法中，在方法中，對(duì)引用所指對(duì)象做相應(yīng)修改。但有時(shí)，我們希望構(gòu)造出一個(gè)和已經(jīng)存在的對(duì)象具有完全相同的內(nèi)容，但引用不同的對(duì)象，為此，可以這樣做：

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

public class DeepCloneTest{

 // must implements Cloneable.
 private class CloneTest implements Cloneable{
  private Object o = new Object();

  public CloneTest clone() {
   CloneTest ct = null;
   try {
    ct = (CloneTest)super.clone();
   } catch (CloneNotSupportedException e) {
    e.printStackTrace();
   }
   return ct;
  }
 }

 public static void main(String args[]) {
  new DeepCloneTest().Test();
 }

 public void Test() {
  CloneTest ct1 = new CloneTest();
  CloneTest ct2 = ct1.clone();

  // to see if ct1 and ct2 are one same reference.
  System.out.println("ct1: " + ct1);
  System.out.println("ct2: " + ct2);

  // whether ct1.o == ct2.o ? yes
  System.out.println("ct1.o " + ct1.o);
  System.out.println("ct1.o " + ct1.o);
 }
}

out put:
ct1: DeepCloneTest$CloneTest@c17164
ct2: DeepCloneTest$CloneTest@1fb8ee3
ct1.o java.lang.Object@61de33
ct1.o java.lang.Object@61de33
從輸出可以看出：ct1 和 ct2 確實(shí)是兩個(gè)不同的引用，所以我們想當(dāng)然的認(rèn)為，ct1.o 和 ct2.o 也是兩個(gè)不同的對(duì)象了，但從輸出可以看出并非如此！ct1.o 和 ct2.o 是同一個(gè)對(duì)象！原因在于，雖然用到了克隆，但上面只是淺度克隆，用圖形來表示：

看到上面的 o 了么？其實(shí)是兩個(gè)對(duì)象共享的。這就相當(dāng)于，你本來有一個(gè)羊圈1，里面有一只羊，然后你又弄了一個(gè)羊圈2，在不將羊從羊圈1里牽出來的情況下，將羊也圈在了羊圈2中，你以為你有兩條羊了，其實(shí)呢？大家都知道。

這就是淺度克隆的結(jié)果：如果你想讓兩個(gè)對(duì)象具有獨(dú)立的 o，就必須再對(duì) o 做克隆操作?？赡苡行┤苏J(rèn)為這沒有什么，做就做唄，但想過沒有，如果不止一個(gè) o，還有很多很多的類似 o 的東東，你都逐一去做克隆嗎？顯然是不太現(xiàn)實(shí)的。

一種解決方法是：將對(duì)象先序列化存儲(chǔ)到流中，然后再?gòu)牧糁凶x出對(duì)象，這樣就可以保證讀取出來的數(shù)據(jù)和之前的對(duì)象，里面的值完全相同，就像是一個(gè)完全的拷貝。

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

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class DeepCloneTest {

 // must implements Cloneable.
 private class CloneTest implements Serializable{
  private static final long serialVersionUID = 1L;
  private Object o = new Object();

  public CloneTest deepClone() {
   CloneTest ct = null;
   try {
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
             ObjectOutputStream oos = new ObjectOutputStream(baos); 
             oos.writeObject(this);
             ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); 
             ObjectInputStream ois= new ObjectInputStream(bais); 
             ct = (CloneTest)ois.readObject(); 
   } catch (IOException e) {
    e.printStackTrace();
   } catch (ClassNotFoundException e) {
    e.printStackTrace();
   }
   return ct;
  }
 }

 public static void main(String args[]) {
  new DeepCloneTest().Test();
 }

 public void Test() {
  CloneTest ct1 = new CloneTest();
  CloneTest ct2 = ct1.deepClone();

  // to see if ct1 and ct2 are one same reference.
  System.out.println("ct1: " + ct1);
  System.out.println("ct2: " + ct2);

  // whether ct1.o == ct2.o ? no
  System.out.println("ct1.o " + ct1.o);
  System.out.println("ct1.o " + ct1.o);
 }
}