這兩者都算是java基礎中的基礎，平常寫程式碼可能並沒有過多的去深究它，但這樣容易引發一些不可預知的BUG。

這裡有一個簡單的類，文章中會提到多次。

一個學生類，它有兩個屬性，String型別的name與Integer型別的age。

public class Student {
    private String name;
    private Integer age;

    public Student() {
    }

    public Student(String name, Integer age) {
        this.name = name;
        this
 
.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

首先我們有一個List。

        ArrayList<Student> originalList = new ArrayList();
        list1.add(new Student("五更琉璃"
 
, 15));
        list1.add(new Student("高阪桐乃", 14));

1、先說說最簡單粗暴的複製。

        ArrayList<Student> copyList = new ArrayList<>();
        copyList = originalList;

        copyList.set(1,new Student("土間埋",16));

copyList直接獲得originalList的引用

originalList ==>
Student{name='五更琉璃', age=15
 
}
Student{name='土間埋', age=16}

copyList ==>
Student{name='五更琉璃', age=15}
Student{name='土間埋', age=16}

結果如下，我們發現，即使只改變了copyList的元素element，原來的ArrayList也跟著變了。

originalList = {[email protected]531}  size = 2
 0 = {[email protected]533} "Student{name='五更琉璃', age=15}"
 1 = {[email protected]534} "Student{name='土間埋', age=16}"
copyList = {[email protected]531}  size = 2
 0 = {[email protected]533} "Student{name='五更琉璃', age=15}"
 1 = {[email protected]534} "Student{name='土間埋', age=16}"

打個斷點我們可以發現，無論是ArrayList，還是裡面的引用，它們的記憶體地址是完全一樣的。

也就是說，直接賦值 copyList = originalList;的這種方法，很難稱得上是一種複製。

2、使用clone方法進行復制

        ArrayList<Student> copyList = (ArrayList<Student>) originalList.clone();
        copyList.set(1,new Student("土間埋",16));

結果如下：看起來正常了，我們的originalList並沒有因為copyList的set方法而改變。

originalList ==>
Student{name='五更琉璃', age=15}
Student{name='高阪桐乃', age=14}

copyList ==>
Student{name='五更琉璃', age=15}
Student{name='土間埋', age=16}

然而開啟斷點會發現，不是那麼一回事。

我們發現，originalList和copyList的指向確實不同了。
然而List中的元素，指向的還是同一塊地址。

originalList = {[email protected]531}  size = 2
 0 = {[email protected]534} "Student{name='五更琉璃', age=15}"
 1 = {[email protected]535} "Student{name='高阪桐乃', age=14}"
copyList = {[email protected]532}  size = 2
 0 = {[email protected]534} "Student{name='五更琉璃', age=15}"
 1 = {[email protected]539} "Student{name='土間埋', age=16}"

也就是說，如果我們不進行set重新修改元素的指向，而是直接改變元素內的屬性。

        ArrayList<Student> copyList = (ArrayList<Student>) originalList.clone();
        copyList.get(1).setName("土間埋");
        copyList.get(1).setAge(16);

從斷點中我們可以得到我們的預期。originalList 中的第一個元素，也會被改變。

originalList = {[email protected]463}  size = 2
 0 = {[email protected]466} "Student{name='五更琉璃', age=15}"
 1 = {[email protected]467} "Student{name='土間埋', age=16}"
copyList = {[email protected]464}  size = 2
 0 = {[email protected]466} "Student{name='五更琉璃', age=15}"
 1 = {[email protected]467} "Student{name='土間埋', age=16}"

從這裡可以看出，ArrayList提供的clone方法，實際上是一種淺複製。

也就是它不是一種遞迴複製。

它只是改變了頂層，copyList 的引用。

我們看看原始碼

 public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

原始碼中，先是clone了一個新的ArrayList：v

然後將原ArrayList中的資料直接複製到了新的ArrayList中。

再看看ArrayList中的add與addAll方法，實際上也是如出一轍。

   public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }

它們只是把元素的引用複製了一遍。也就是說呼叫clone、add、addAll方法，當改變元素中的屬性時，新List中的元素也會跟著改變。

java的引數傳遞也是如此，java中，引數的傳遞都是值傳遞。當一個物件例項作為一個引數被傳遞到方法中時，引數的值就是該物件的引用一個副本。

當這個副本的屬性在方法內部被改變時，這個副本的正本也會被改變。

那麼就針對當前業務來說，如何實現深克隆？

        ArrayList<Student> copyList = new ArrayList<>();
        for (Student student : originalList) {
            copyList.add(student.clone());
        }

        copyList.get(1).setName("土間埋");
        copyList.get(1).setAge(16);

粗暴實現：我們發現它們的地址已經完全不同了。

originalList = {[email protected]464}  size = 2
 0 = {[email protected]467} "Student{name='五更琉璃', age=15}"
 1 = {[email protected]468} "Student{name='高阪桐乃', age=14}"
copyList = {[email protected]465}  size = 2
 0 = {[email protected]472} "Student{name='五更琉璃', age=15}"
 1 = {[email protected]473} "Student{name='土間埋', age=16}"

2018年7月17日 補充，偶然回顧這篇文章，其實還有一種又快又好的深複製方法：序列化，將物件轉成進行序列化再反序列化即可，效率還是挺高的（不適用於複雜物件）..