關於Java的深拷貝與淺拷貝

假如說你想複製一個簡單變量。很簡單：

int apples = 5;
int pears = apples;

不僅僅是int類型，其它七種原始數據類型(boolean,char,byte,short,float,double.long)同樣適用於該類情況。

但是如果你複製的是一個對象，情況就有些複雜了。

假設說我是一個beginner，我會這樣寫：

class Student {
    private int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

}
public class Test {

    public static void main(String args[]) {

        Student stu1 = new Student();
        stu1.setNumber(12345);
        Student stu2 = stu1;

        System.out.println("學生1:" + stu1.getNumber());
        System.out.println("學生2:" + stu2.getNumber());
    }
}

打印結果：

學生1:12345
學生2:12345

這裏我們自定義了一個學生類，該類只有一個number字段。

我們新建了一個學生實例，然後將該值賦值給stu2實例。(Student stu2 = stu1;)

再看看打印結果，作爲一個新手，拍了拍胸腹，對象複製不過如此，

難道真的是這樣嗎？

我們試着改變stu2實例的number字段，再打印結果看看：

stu2.setNumber(54321);

System.out.println("學生1:" + stu1.getNumber());
System.out.println("學生2:" + stu2.getNumber());

打印結果:

學生1:54321
學生2:54321

這就怪了，爲什麼改變學生2的學號，學生1的學號也發生了變化呢？

原因出在(stu2 = stu1) 這一句。該語句的作用是將stu1的引用賦值給stu2，

這樣，stu1和stu2指向內存堆中同一個對象。如圖：

那麼，怎樣才能達到複製一個對象呢？

是否記得萬類之王Object。它有11個方法，有兩個protected的方法，其中一個爲clone方法。

該方法的簽名是：

protected native Object clone() throws CloneNotSupportedException;

因爲每個類直接或間接的父類都是Object，因此它們都含有clone()方法，但是因爲該方法是protected，所以都不能在類外進行訪問。

要想對一個對象進行復制，就需要對clone方法覆蓋。

一般步驟是（淺複製）：

1. 被複制的類需要實現Clonenable接口（不實現的話在調用clone方法會拋出CloneNotSupportedException異常) 該接口爲標記接口(不含任何方法)

2. 覆蓋clone()方法，訪問修飾符設爲public。方法中調用super.clone()方法得到需要的複製對象，（native爲本地方法)

下面對上面那個方法進行改造：

class Student implements Cloneable{
    private int number;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return stu;
    }
}
public class Test {

    public static void main(String args[]) {

        Student stu1 = new Student();
        stu1.setNumber(12345);
        Student stu2 = (Student)stu1.clone();

        System.out.println("學生1:" + stu1.getNumber());
        System.out.println("學生2:" + stu2.getNumber());

        stu2.setNumber(54321);

        System.out.println("學生1:" + stu1.getNumber());
        System.out.println("學生2:" + stu2.getNumber());
    }
}

打印結果：

學生1:12345
學生2:12345
學生1:12345
學生2:54321

如果你還不相信這兩個對象不是同一個對象，那麼你可以看看這一句：

System.out.println(stu1 == stu2); // false

上面的複製被稱爲淺複製(Shallow Copy)，還有一種稍微複雜的深度複製(deep copy)：

我們在學生類裏再加一個Address類。

class Address  {
    private String add;

    public String getAdd() {
        return add;
    }

    public void setAdd(String add) {
        this.add = add;
    }

}

class Student implements Cloneable{
    private int number;

    private Address addr;

    public Address getAddr() {
        return addr;
    }

    public void setAddr(Address addr) {
        this.addr = addr;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return stu;
    }
}
public class Test {

    public static void main(String args[]) {

        Address addr = new Address();
        addr.setAdd("杭州市");
        Student stu1 = new Student();
        stu1.setNumber(123);
        stu1.setAddr(addr);

        Student stu2 = (Student)stu1.clone();

        System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
        System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
    }
}

打印結果：

學生1:123,地址:杭州市
學生2:123,地址:杭州市

乍一看沒什麼問題，真的是這樣嗎？

我們在main方法中試着改變addr實例的地址。

addr.setAdd("西湖區");

System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());

打印結果：

學生1:123,地址:杭州市
學生2:123,地址:杭州市
學生1:123,地址:西湖區
學生2:123,地址:西湖區

這就奇怪了，怎麼兩個學生的地址都改變了？

原因是淺複製只是複製了addr變量的引用，並沒有真正的開闢另一塊空間，將值複製後再將引用返回給新對象。

所以，爲了達到真正的複製對象，而不是純粹引用複製。我們需要將Address類可複製化，並且修改clone方法，完整代碼如下：

package abc;

class Address implements Cloneable {
    private String add;

    public String getAdd() {
        return add;
    }

    public void setAdd(String add) {
        this.add = add;
    }

    @Override
    public Object clone() {
        Address addr = null;
        try{
            addr = (Address)super.clone();
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return addr;
    }
}

class Student implements Cloneable{
    private int number;

    private Address addr;

    public Address getAddr() {
        return addr;
    }

    public void setAddr(Address addr) {
        this.addr = addr;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    @Override
    public Object clone() {
        Student stu = null;
        try{
            stu = (Student)super.clone();   //淺複製
        }catch(CloneNotSupportedException e) {
            e.printStackTrace();
        }
        stu.addr = (Address)addr.clone();   //深度複製
        return stu;
    }
}
public class Test {

    public static void main(String args[]) {

        Address addr = new Address();
        addr.setAdd("杭州市");
        Student stu1 = new Student();
        stu1.setNumber(123);
        stu1.setAddr(addr);

        Student stu2 = (Student)stu1.clone();

        System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
        System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());

        addr.setAdd("西湖區");

        System.out.println("學生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());
        System.out.println("學生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());
    }
}

打印結果：

學生1:123,地址:杭州市
學生2:123,地址:杭州市
學生1:123,地址:西湖區
學生2:123,地址:杭州市

這樣結果就符合我們的想法了。

最後我們可以看看API裏其中一個實現了clone方法的類：

java.util.Date:

/**
 * Return a copy of this object.
 */
public Object clone() {
    Date d = null;
    try {
        d = (Date)super.clone();
        if (cdate != null) {
            d.cdate = (BaseCalendar.Date) cdate.clone();
        }
    } catch (CloneNotSupportedException e) {} // Won't happen
    return d;
}

該類其實也屬於深度複製。