Java基礎使用技巧：深拷貝的兩種方式

　　⑴淺復制(淺克隆)

　　被復制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用仍然指向原來的對象。換言之，淺復制僅僅復制所考慮的對象，而不復制它所引用的對象。

　　⑵深復制(深克隆)

　　被復制對象的所有變量都含有與原來的對象相同的值，除去那些引用其他對象的變量。那些引用其他對象的變量將指向被復制過的新對象，而不再是原有的那些被引用的對象。換言之，深復制把要復制的對象所引用的對象都復制了一遍。

　　Java的clone()方法

　　⑴clone方法將對象復制了一份並返回給調用者。一般而言，clone()方法滿足：

　　①對任何的對象x，都有x.clone() !=x//克隆對象與原對象不是同一個對象

　　②對任何的對象x，都有x.clone().getClass()= =x.getClass()//克隆對象與原對象的類型一樣

　　③如果對象x的equals()方法定義恰當，那麼x.clone().equals(x)應該成立。

　　⑵Java中對象的克隆

　　①為了獲取對象的一份拷貝，我們可以利用Object類的clone()方法。

　　②在派生類中覆蓋基類的clone()方法，並聲明為public。

　　③在派生類的clone()方法中，調用super.clone()。

　　④在派生類中實現Cloneable接口。

　　請看如下代碼：

　　class Student implements Cloneable

　　{

　　String name;

　　int age;

　　Student(String name,int age)

　　{

　　this.name=name;

　　this.age=age;

　　}

　　public Object clone()

　　{

　　Object o=null;

　　try

　　{

　　o=(Student)super.clone();//Object中的clone()識別出你要復制的是哪一

　　// 個對象。

　　}

　　catch(CloneNotSupportedException e)

　　{

　　System.out.println(e.toString());

　　} return o;

　　}

　　}

　　public static void main(String[] args)

　　{

　　Student s1=new Student("zhangsan",18);

　　Student s2=(Student)s1.clone();

　　s2.name="lisi";

　　s2.age=20;

　　System.out.println("name="+s1.name+","+"age="+s1.age);//修改學生2後，不影響 //學生1的值。

　　}

　　說明：

　　①為什麼我們在派生類中覆蓋Object的clone()方法時，一定要調用super.clone()呢?在運行時刻，Object中的 clone()識別出你要復制的是哪一個對象，然後為此對象分配空間，並進行對象的復制，將原始對象的內容一一復制到新對象的存儲空間中。

　　②繼承自java.lang.Object類的clone()方法是淺復制。以下代碼可以證明之。

　　class Professor

　　{

　　String name;

　　int age;

　　Professor(String name,int age)

　　{

　　this.name=name;

　　this.age=age;

　　}

　　}

　　class Student implements Cloneable

　　{

　　String name;//常量對象。

　　int age;

　　Professor p;//學生1和學生2的引用值都是一樣的。

　　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 static void main(String[] args)

　　{

　　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的教授 //成為lisi,age為30。

　　}

　　那應該如何實現深層次的克隆，即修改s2的教授不會影響s1的教授?代碼改進如下。

　　改進使學生1的Professor不改變(深層次的克隆)

　　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 static void main(String[] args)

　　{

　　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的教授不改變。

　　}

　　3.利用串行化來做深復制

　　把對象寫到流裡的過程是串行化(Serilization)過程，但是在Java程序師圈子裡又非常形象地稱為“冷凍”或者“腌鹹菜(picking)”過程;而把對象從流中讀出來的並行化(Deserialization)過程則叫做“解凍”或者“回鮮(depicking)”過程。應當指出的是，寫在流裡的是對象的一個拷貝，而原對象仍然存在於JVM裡面，因此“腌成鹹菜”的只是對象的一個拷貝，Java鹹菜還可以回鮮。

　　在Java語言裡深復制一個對象，常常可以先使對象實現Serializable接口，然後把對象(實際上只是對象的一個拷貝)寫到一個流裡(腌成鹹菜)，再從流裡讀出來(把鹹菜回鮮)，便可以重建對象。

　　如下為深復制源代碼。

　　public Object deepClone()

　　{

　　//將對象寫到流裡

　　ByteArrayOutoutStream 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());

　　}

　　這樣做的前提是對象以及對象內部所有引用到的對象都是可串行化的，否則，就需要仔細考察那些不可串行化的對象可否設成transient，從而將之排除在復制過程之外。上例代碼改進如下。

　　class Professor implements Serializable

　　{

　　String name;

　　int age;

　　Professor(String name,int age)

　　{

　　this.name=name;

　　this.age=age;

　　}

　　}

　　class Student implements Serializable

　　{

　　String name;//常量對象。

　　int age;

　　Professor p;//學生1和學生2的引用值都是一樣的。

　　Student(String name,int age,Professor p)

　　{

　　this.name=name;

　　this.age=age;

　　this.p=p;

　　}

　　public Object deepClone() throws IOException,

　　OptionalDataException,ClassNotFoundException

　　{

　　//將對象寫到流裡

　　ByteArrayOutoutStream 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());