細數淺拷貝和深拷貝
Java 對象拷貝是為對象賦值的一種方式，簡單來說就是創建一個和原對象相同的對象，新創建的對象是原對象的一個副本，面試官賊拉喜歡在面試的時候問一問你淺拷貝和深拷貝的原理。因為它涉及到對象的引用關係，涉及到 Java 是傳值還是傳遞引用關係，這通常是面試的重點。所以在聊深拷貝和淺拷貝之前，我們先來聊一聊引用關係。
關於引用
在 Java 中，除了基本數據類型（四類八種數據類型）之外，還存在引用數據類型。一般使用 = 號做賦值操作的時候，對於基本數據類型，實際上是拷貝的它的值，但是對於對象而言，其實賦值的只是這個對象的引用，也就是將原對象的引用傳遞過去，但是他們實際上還是指向的同一個對象。如下代碼所示
public class Food{
String name;
int num;
String taste;
constructor()
get and set()
toString()
}
測試類：
public static void main(String[] args) {
int i1 = 10;
int i2 = i1; // 基本數據類型的拷貝，拷貝值
System.out.println("i2 = " + i2);
Food milk = new Food("milk",1,"fragrance");
Food food = milk;
System.out.printf("food = " + food);
System.out.println("milk = " + milk); // milk 和 food 都指向同一個堆內存對象
}
如果用圖表示的話，應該是下面這樣的：
不用糾結 Java 中到底是值傳遞還是引用傳遞這種無意義的爭論中，你只要記得對於基本數據類型，傳遞的是數據類型的值，而對於引用類型來說，傳遞的是對象的引用，也就是對象的地址就可以了。
關於淺拷貝和深拷貝
淺拷貝和深拷貝其實就是在引用的這個基礎上來做區分的，如果在拷貝的時候，只對基本數據類型進行拷貝，對引用數據類型只是進行了引用的傳遞，沒有真正的創建一個新的對象，這種拷貝方式就認為是淺拷貝。反之，在對引用數據類型進行拷貝的時候，創建了一個新的對象，並且複製其內的成員變量，這種拷貝方式就被認為是深拷貝。
淺拷貝
那麼如何實現淺拷貝(Shallow copy)呢？很簡單，就是在需要拷貝的類上實現 Cloneable 接口並重寫其 clone() 方法就可以了。
下面我們對 Food 類進行修改，我們讓他實現 Cloneable 接口，並重寫 clone() 方法。
public class Food implements Cloneable{
...
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
...
}
然後在測試類中的代碼如下
Food milk = new Food("milk",1,"fragrance");
Food food = (Food)milk.clone();
System.out.println("milk = " + milk);
System.out.println("food = " + food);
可以看到，現在的 food 對象是由 milk 對象拷貝出來的，那麼此時的 food 對象和 milk 對象是同一個對象嗎？我們通過打印，可以看到這兩個對象的原生 hashcode。
milk = com.cxuan.objectclone.Food@3cd1a2f1
food = com.cxuan.objectclone.Food@4d7e1886
可以發現，food 和 milk 並不是同一個對象，那 milk 中還有三個屬性值，這三個屬性值在 food 中是不是也一樣呢？為了驗證這個猜想，我們重寫了 toString 方法。
@Override
public String toString() {
return "Food{" +
"name='" + name + '\'' +
", num=" + num +
", taste='" + taste + '\'' +
'}';
}
然後再次打印 food 和 milk ，可以觀察到如下結果
milk = Food{name='milk', num=1, taste='fragrance'}
food = Food{name='milk', num=1, taste='fragrance'}
嗯哼，雖然看起來”cxuan 哥”和”cuan 哥”是兩種完全不同的稱呼！但是他們卻有一種共同的能力：寫作！
我們還是通過圖示來說明一下：
這幅圖看出門道了么？在堆區分別出現了兩個 Food 對象，這同時表明 clone 方法會重新創建一個對象並為其分配一塊內存區域；雖然出現了兩個對象，但是兩個對象中的屬性值是一樣的，這也是換湯不換藥，雖然湯和葯是不同的東西（對象），但是他們都溶於水（屬性值）。
深拷貝
雖然淺拷貝是一種換湯不換藥的說法，但是在 Java 世界中還是有一種說法是。。。。。。是啥來着？
詞窮了。。。。。。
哦對，還有一種改頭換面的形式，它就是我們所熟悉的深拷貝(Deep copy)，先來拋出一下深拷貝的定義：在進行對象拷貝的基礎上，對對象的成員變量也依次拷貝的方式被稱為深拷貝。
哈哈哈哈，這故作高深的深拷貝原來就是在淺拷貝的基礎上再複製一下它的屬性值啊，我還以為是啥高深的東西呢！上代碼！
我們先增加一個飲品類 Drink 。
public class Drink implements Cloneable {
String name;
get and set()
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
toString()
}
然後更改一下 Food 類，因為 Drink 也算是 Food ，所以我們在 Food 類中增加對 Drink 的引用，然後再修改 get set 、toString 、clone 、構造方法，修改後的 Food 類代碼如下
public class Food implements Cloneable{
String name;
int num;
String taste;
Drink drink;
public Food(String name, int num, String taste,Drink drink) {
this.name = name;
this.num = num;
this.taste = taste;
this.drink = drink;
}
get and set...
@Override
protected Object clone() throws CloneNotSupportedException {
Food food = (Food)super.clone();
food.drink = (Drink) drink.clone();
return super.clone();
}
@Override
public String toString() {
return "Food{" +
"name='" + name + '\'' +
", num=" + num +
", taste='" + taste + '\'' +
", drink=" + drink +
'}';
}
}
可以看到最大的改變是 clone 方法，我們在 clone 方法中，實現了對 Food 對象的拷貝，同時也實現了對 Drink 對象的拷貝，這就是我們上面所說的複製對象並複製對象的成員變量。
然後我們進行一下 Deep Copy的測試：
public static void main(String[] args) throws CloneNotSupportedException {
Drink drink = new Drink("milk");
Food food = new Food("humberge",1,"fragrance",drink);
Food foodClone = (Food)food.clone();
Drink tea = new Drink("tea");
food.setDrink(tea);
System.out.println("food = " + food);
System.out.println("foodClone = " + foodClone.getDrink());
}
運行完成後的輸出結果如下：
food = Food{name='humberge', num=1, taste='fragrance', drink=Drink{name='tea'}}
foodClone = Drink{name='milk'}
可以看到，我們把 foodClone 拷貝出來之後，修改 food 中的 drink 變量，卻不會對 foodClone 造成改變，這就說明 foodClone 已經成功實現了深拷貝。
用圖示表示的話，應該是下面這樣的：
這是深拷貝之後的內存分配圖，現在可以看到，food 和 foodClone 完全是兩個不同的對象，它們之間不存在紐帶關係。
我們上面主要探討實現對象拷貝的方式是對象實現 Cloneable 接口，並且調用重寫之後的 clone 方法，在 Java 中，還有一種實現對象拷貝的方式是使用 序列化。
序列化
使用序列化的方式主要是使用 Serializable 接口，這種方式還以解決多層拷貝的問題，多層拷貝就是引用類型裏面又有引用類型，層層嵌套下去。使用 Serializable 的關鍵代碼如下
public Person clone() {
Person person = null;
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
// 將流序列化成對象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
person = (Person) ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return person;
}
使用序列化可以實現深拷貝，它的原理是將二進制位元組流內容寫到一個文本或位元組數組，然後是從這個文本或者位元組數組中讀取數據，原對象寫入這個文本或者位元組數組後再拷貝給 clone 對象，原對象的修改不會影響 clone 對象，因為 clone 對象是從文本或者位元組數組中讀取的。
如何選擇拷貝方式
到現在我們已經把淺拷貝和深拷貝都介紹完了，那麼如何選擇淺拷貝和深拷貝呢？下面是幾點注意事項⚠️
-
如果對象的屬性都是基本數據類型，那麼可以使用淺拷貝。
-
如果對象有引用類型，那就要基於具體的需求來選擇淺拷貝還是深拷貝。
-
如果對象嵌套層數比較多，推薦使用 Serializable 接口實現深拷貝。
-
如果對象引用任何時候都不會被改變，那麼沒必要使用深拷貝，只需要使用淺拷貝就行了。如果對象引用經常改變，那麼就要使用深拷貝。沒有一成不變的規則，一切都取決於具體需求。
其他拷貝方式
除了對象的拷貝，Java 中還提供了其他的拷貝方式
比如數組的拷貝，你可以使用 Arrays.copyof 實現數組拷貝，還可以使用默認的 clone 進行拷貝，不過這兩者都是淺拷貝。
public void test() {
int[] lNumbers1 = new int[5];
int[] rNumbers1 = Arrays.copyOf(lNumbers1, lNumbers1.length);
int[] lNumbers2 = new int[5];
int[] rNumbers2 = lNumbers2.clone();
}
除了基本數組數據類型之外的拷貝，還有對象的拷貝，不過用法基本是一樣的。
集合也可以實現拷貝，因為集合的底層就使用的是數組，所以用法也是一樣的。
一些說明
針對 Cloneable 接口，有下面三點使用說明
-
如果類實現了 Cloneable 接口，再調用 Object 的 clone() 方法可以合法地對該類實例進行按字段複製。
-
如果在沒有實現 Cloneable 接口的實例上調用 Object 的 clone() 方法，則會導致拋出
CloneNotSupporteddException。 -
實現此接口的類應該使用公共方法重寫 Object 的clone() 方法，因為 Object 的 clone() 方法是一個受保護的方法。
