java深拷貝和淺拷貝

標籤：內容   需要   cep   string   support   pcl   原始碼   對象   方法   

1、概念

java裡的clone分為： 
A:淺複製（淺複製）: 淺複製僅僅複製所考慮的對象，而不複製它所引用的對象。 
b:深複製（深複製）：深複製把要複製的對象所引用的對象都複製了一遍。 
Java中對象的複製,為了擷取對象的一份拷貝，我們可以利用Object類的clone()方法。必須要遵循下面三點 
1.在衍生類別中覆蓋基類的clone()方法，並聲明為public【Object類中的clone()方法為protected的】。 
2.在衍生類別的clone()方法中，調用super.clone()。 
3.在衍生類別中實現Cloneable介面。 

註明：Object類裡的clone方法是淺複製（淺複製）

2．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介面。 

請看下面代碼：

public 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;        //修改學生2後，不影響學生1的值。        System.out.println("name="+s1.name+","+"age="+s1.age);        System.out.println("name="+s2.name+","+"age="+s2.age);    }} 

　　說明： 
①為什麼我們在衍生類別中覆蓋Object的clone()方法時，一定要調用super.clone()呢？在運行時刻，Object中的clone()識別出你要複製的是哪一個對象，然後為此對象分配空間，並進行對象的複製，將原始對象的內容一一複製到新對象的儲存空間中。 
②繼承自java.lang.Object類的clone()方法是淺複製。以下代碼可以證明之。

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;    }}public 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;        //學生1的教授不 改變。        System.out.println("name="+s1.p.name+","+"age="+s1.p.age);        System.out.println("name="+s2.p.name+","+"age="+s2.p.age);    }} 

那應該如何?深層次的複製，即修改s2的教授不會影響s1的教授？代碼改進如下。 
改進使學生1的Professor不改變（深層次的複製）

public 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;        //學生1的教授不 改變。        System.out.println("name="+s1.p.name+","+"age="+s1.p.age);        System.out.println("name="+s2.p.name+","+"age="+s2.p.age);    }} 

　　3．利用序列化來做深複製（主要是為了避免重寫比較複雜物件的深複製的clone（）方法，也可以程式實現斷點續傳等等功能） 
    把對象寫到流裡的過程是序列化（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 Teacher implements Serializable {    String name;    int age;    public void Teacher(String name,int age){        this.name=name;        this.age=age;    }}public class Student implements Serializable{    String name;//常量對象    int age;    Teacher t;//學生1和學生2的引用值都是一樣的。    public void Student(String name,int age,Teacher t){        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());    }    public static void main(String[] args){        Teacher t=new Teacher("tangliang",30);        Student s1=new Student("zhangsan",18,t);        Student s2=(Student)s1.deepClone();        s2.t.name="tony";        s2.t.age=40;        //學生1的老師不改變        System.out.println("name="+s1.t.name+","+"age="+s1.t.age);    }}

　參考：http://www.jb51.net/article/62909.html

 

java深拷貝和淺拷貝