java對象克隆以及深拷貝和淺拷貝

1.什么是"克隆"？

在實際編程過程中，我們常常要遇到這種情況：有一個對象A，在某一時刻A中已經包含了一些有效值，此時可能 會需要一個和A完全相同新對象B，並且此后對B任何改動都不會影響到A中的值，也就是說，A與B是兩個獨立的對象，但B的初始值是由A對象確定的。在 Java語言中，用簡單的賦值語句是不能滿足這種需求的。要滿足這種需求雖然有很多途徑，但實現clone（）方法是其中最簡單，也是最高效的手段。 
Java的所有類都默認繼承java.lang.Object類，在java.lang.Object類中有一個方法clone()。JDK API的說明文檔解釋這個方法將返回Object對象的一個拷貝。要說明的有兩點：一是拷貝對象返回的是一個新對象，而不是一個引用。二是拷貝對象與用 new操作符返回的新對象的區別就是這個拷貝已經包含了一些原來對象的信息，而不是對象的初始信息。 

2.怎樣應用clone方法

一個很典型的調用clone()代碼如下： 

class CloneClass implements Cloneable{ 
　public int aInt; 
　public Object clone(){ 
　　CloneClass o = null; 
　　try{ 
　　　o = (CloneClass)super.clone(); 
　　}catch(CloneNotSupportedException e){ 
　　　e.printStackTrace(); 
　　} 
　　return o; 
　} 
｝

有三個值得注意的地方，一是希望能實現clone功能的CloneClass類實現了Cloneable接口，這個接口屬於java.lang 包，java.lang包已經被缺省的導入類中，所以不需要寫成java.lang.Cloneable。另一個值得請注意的是重載了clone()方 法。最后在clone()方法中調用了super.clone()，這也意味着無論clone類的繼承結構是什么樣的，super.clone()直接或 間接調用了java.lang.Object類的clone()方法。下面再詳細的解釋一下這幾點。 

應該說第三點是最重要的，仔細 觀察一下Object類的clone()一個native方法，native方法的效率一般來說都是遠高於java中的非native方法。這也解釋了為 什么要用Object中clone()方法而不是先new一個類，然后把原始對象中的信息賦到新對象中，雖然這也實現了clone功能。對於第二點，也要 觀察Object類中的clone()還是一個protected屬性的方法。這也意味着如果要應用clone()方法，必須繼承Object類，在 Java中所有的類是缺省繼承Object類的，也就不用關心這點了。然后重寫clone()方法。還有一點要考慮的是為了讓其它類能調用這個clone 類的clone()方法，重寫之后要把clone()方法的屬性設置為public。 

那么clone類為什么還要實現 Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其實這個接口僅僅是一個標志，而且這個標志也僅僅是針對 Object類中clone()方法的，如果clone類沒有實現Cloneable接口，並調用了Object的clone()方法（也就是調用了 super.Clone()方法），那么Object的clone()方法就會拋出CloneNotSupportedException異常。 

3.深拷貝與淺拷貝

淺拷貝是指拷貝對象時僅僅拷貝對象本身（包括對象中的基本變量），而不拷貝對象包含的引用指向的對象。深拷貝不僅拷貝對象本身，而且拷貝對象包含的引用指向的所有對象。舉例來說更加清楚：對象A1中包含對B1的引用，B1中包含對C1的引用。淺拷貝A1得到A2，A2 中依然包含對B1的引用，B1中依然包含對C1的引用。深拷貝則是對淺拷貝的遞歸，深拷貝A1得到A2，A2中包含對B2（B1的copy）的引用，B2 中包含對C2（C1的copy）的引用。

若不對clone()方法進行改寫，則調用此方法得到的對象即為淺拷貝，下面我們着重談一下深拷貝。運行下面的程序，看一看淺拷貝：

class Professor0 implements Cloneable {
    String name;
    int age;
 
    Professor0(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Student0 implements Cloneable {
    String name;// 常量對象。
    int age;
    Professor0 p;// 學生1和學生2的引用值都是一樣的。
 
    Student0(String name, int age, Professor0 p) {
        this.name = name;
        this.age = age;
        this.p = p;
    }
 
    public Object clone() {
        Student0 o = null;
        try {
            o = (Student0) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
 
        return o;
    }
}

public class ShallowCopy {
    public static void main(String[] args) {
        Professor0 p = new Professor0("wangwu", 50);
        Student0 s1 = new Student0("zhangsan", 18, p);
        Student0 s2 = (Student0) s1.clone();
        s2.p.name = "lisi";
        s2.p.age = 30;
        s2.name = "z";
        s2.age = 45;
        System.out.println("學生s1的姓名：" + s1.name + "\n學生s1教授的姓名：" + s1.p.name + "," + "\n學生s1教授的年紀" + s1.p.age);// 學生1的教授
    }
}

運行結果：

s2變了，但s1也變了，證明s1的p和s2的p指向的是同一個對象。這在我們有的實際需求中，卻不是這樣，因而我們需要深拷貝：

class Professor implements Cloneable {
    String name;
    int age;
 
    Professor(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public Object clone() {
        Object o = null;
        try {
            o = super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        return o;
    }
}

class Student implements Cloneable {
    String name;
    int age;
    Professor p;
 
    Student(String name, int age, Professor p) {
        this.name = name;
        this.age = age;
        this.p = p;
    }
 
    public Object clone() {
        Student o = null;
        try {
            o = (Student) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println(e.toString());
        }
        o.p = (Professor) p.clone();
        return o;
    }
}

public class DeepCopy {
    public static void main(String args[]) {
        long t1 = System.currentTimeMillis();
        Professor p = new Professor("wangwu", 50);
        Student s1 = new Student("zhangsan", 18, p);
        Student s2 = (Student) s1.clone();
        s2.p.name = "lisi";
        s2.p.age = 30;
        System.out.println("name=" + s1.p.name + "," + "age=" + s1.p.age);// 學生1的教授不改變。
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
    }
}

運行結果：

當然我們還有一種深拷貝方法，就是將對象串行化：

class Professor2 implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    String name;
    int age;
 
    Professor2(String name, int age) {
        this.name = name;
        this.age = age;
    }

class Student2 implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    String name;// 常量對象。
    int age;
    Professor2 p;// 學生1和學生2的引用值都是一樣的。
 
    Student2(String name, int age, Professor2 p) {
        this.name = name;
        this.age = age;
        this.p = p;
    }
 
    public Object deepClone() throws IOException, OptionalDataException,
            ClassNotFoundException {
        // 將對象寫到流里
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);
        // 從流里讀出來
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return (oi.readObject());
    }
 
}

public class DeepCopy2 {
     
    /**
     * @param args
     */
    public static void main(String[] args) throws OptionalDataException,
            IOException, ClassNotFoundException {
        long t1 = System.currentTimeMillis();
        Professor2 p = new Professor2("wangwu", 50);
        Student2 s1 = new Student2("zhangsan", 18, p);
        Student2 s2 = (Student2) s1.deepClone();
        s2.p.name = "lisi";
        s2.p.age = 30;
        System.out.println("name=" + s1.p.name + "," + "age=" + s1.p.age); // 學生1的教授不改變。
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
    }
 
}

要想序列化對象，必須先創建一個OutputStream，然后把它嵌入ObjectOutputStream。這時就能用writeObject()方法把對象寫入OutputStream。讀的時候需要把InputStream嵌到ObjectInputStream中，然后再調用readObject()方法。不過這樣讀出來的只是一個Object的reference，因此，在用之前，還要下轉型。

對象序列化不僅能保存對象的副本，而且會跟着對象中的reference把它所引用的對象也保存起來，然后再繼續跟蹤那些對象的reference，以此類推。這種情形常被稱作”單個對象所聯結的‘對象網’ “。

但是串行化卻很耗時，在一些框架中，我們便可以感受到，它們往往將對象進行串行化后進行傳遞，耗時較多。

本篇文章來源於兩位前輩的博文，以及《java程序員面試寶典》。為了表示對他人勞動成果的尊重，這里標注出處：

http://www.cnblogs.com/shuaiwhu/archive/2010/12/14/2065088.html
http://www.cnblogs.com/o-andy-o/archive/2012/04/06/2434904.html