深淺克隆面試題匯總——附詳細答案

2019 年 10 月 5 日
筆記

在開始學習深克隆和淺克隆之前，我們先來看下面程式碼，有什麼問題？

class CloneTest {      public static void main(String[] args) throws CloneNotSupportedException {          // 等號賦值（ 基本類型）          int number = 6;          int number2 = number;          // 修改 number2 的值          number2 = 9;          System.out.println("number：" + number);          System.out.println("number2：" + number2);          // 等號賦值（對象）          Dog dog = new Dog();          dog.name = "旺財";          dog.age = 5;          Dog dog2 = dog;          // 修改 dog2 的值          dog2.name = "大黃";          dog2.age = 3;          System.out.println(dog.name + "，" + dog.age + "歲");          System.out.println(dog2.name + "，" + dog2.age + "歲");      }  }

程式執行結果：

number：6  number2：9  大黃，3歲  大黃，3歲

可以看出，如果使用等號複製時，對於值類型來說，彼此之間的修改操作是相對獨立的，而對於引用類型來說，因為複製的是引用對象的記憶體地址，所以修改其中一個值，另一個值也會跟著變化，原理如下圖所示：

因此為了防止這種問題的發生，就要使用對象克隆來解決引用類型複製的問題。

一、淺克隆

淺克隆的默認實現方法是 clone()，實現程式碼如下：

class CloneTest {      public static void main(String[] args) throws CloneNotSupportedException {          Dog dog = new Dog();          dog.name = "旺財";          dog.age = 5;          // 克隆          Dog dog3 = (Dog) dog.clone();          dog3.name = "小白";          dog3.age = 2;          System.out.println(dog.name + "，" + dog.age + "歲");          System.out.println(dog3.name + "，" + dog3.age + "歲");      }  }  class Dog implements Cloneable {      public String name;      public int age;      @Override      protected Object clone() throws CloneNotSupportedException {          return super.clone();      }  }

程式執行結果：

旺財，5歲  小白，2歲

可以看出使用克隆就可以解決引用類型複製的問題了，原理如下圖所示：

以上這種複製方式叫做淺克隆。 淺克隆的實現條件：需要克隆的對象必須實現 Cloneable 介面，並重寫 clone() 方法，即可實現對此對象的克隆。然而使用淺克隆也會存在一個問題，請參考以下程式碼。

class CloneTest {      public static void main(String[] args) throws CloneNotSupportedException {          DogChild dogChild = new DogChild();          dogChild.name = "二狗";          Dog dog4 = new Dog();          dog4.name = "大黃";          dog4.dogChild = dogChild;          Dog dog5 = (Dog) dog4.clone();          dog5.name = "旺財";          dog5.dogChild.name = "狗二";          System.out.println("dog name 4："+dog4.name);          System.out.println("dog name 5："+dog5.name);          System.out.println("dog child name 4："+dog4.dogChild.name);          System.out.println("dog child name 5："+dog5.dogChild.name);      }  }  class Dog implements Cloneable {      public String name;      public DogChild dogChild;      @Override      protected Object clone() throws CloneNotSupportedException {          return super.clone();      }  }  class DogChild {      public String name;  }

程式執行結果：

dog name 4：大黃  dog name 5：旺財  dog child name 4：狗二  dog child name 5：狗二

也就是說淺克隆，只會複製對象的值類型，而不會複製對象的引用類型。原因如下圖所示：

要處理引用類型不被複制的問題，就要使用到深克隆。

二、深克隆

定義：深克隆就是複製整個對象資訊，包含值類型和引用類型。 深克隆的實現方式通常包含以下兩種。

序列化實現深克隆：先將原對象序列化到記憶體的位元組流中，再從位元組流中反序列化出剛剛存儲的對象，這個新對象和原對象就不存在任何地址上的共享，這樣就實現了深克隆。
所有引用類型都實現克隆：要複製對象的所有引用類型都要實現克隆，所有對象都是複製的新對象，從而實現了深克隆。

深克隆實現方式一：序列化

實現思路：先將要拷貝對象寫入到記憶體中的位元組流中，然後再從這個位元組流中讀出剛剛存儲的資訊，作為一個新對象返回，那麼這個新對象和原對象就不存在任何地址上的共享，自然實現了深拷貝。請參考以下程式碼：

class CloneTest {      public static void main(String[] args) throws CloneNotSupportedException {          BirdChild birdChild = new BirdChild();          birdChild.name = "小小鳥";          Bird bird = new Bird();          bird.name = "小鳥";          bird.birdChild = birdChild;          // 使用序列化克隆對象          Bird bird2 = CloneUtils.clone(bird);          bird2.name = "黃雀";          bird2.birdChild.name = "小黃雀";          System.out.println("bird name:" + bird.name);          System.out.println("bird child name:" + bird.birdChild.name);          System.out.println("bird name 2:" + bird2.name);          System.out.println("bird child name 2:" + bird2.birdChild.name);      }  }  class CloneUtils {      public static <T extends Serializable> T clone(T obj) {          T cloneObj = null;          try {              //寫入位元組流              ByteArrayOutputStream bo = new ByteArrayOutputStream();              ObjectOutputStream oos = new ObjectOutputStream(bo);              oos.writeObject(obj);              oos.close();              //分配記憶體,寫入原始對象,生成新對象              ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());//獲取上面的輸出位元組流              ObjectInputStream oi = new ObjectInputStream(bi);              //返回生成的新對象              cloneObj = (T) oi.readObject();              oi.close();          } catch (Exception e) {              e.printStackTrace();          }          return cloneObj;      }  }

程式執行結果：

bird name:小鳥  bird child name:小小鳥  bird name 2:黃雀  bird child name 2:小黃雀

深克隆實現方式二：所有引用類型都實現克隆

class SerializableTest {      public static void main(String[] args) throws IOException, ClassNotFoundException {      ParrotChild parrotChild = new ParrotChild();          parrotChild.name = "小鸚鵡";          Parrot parrot = new Parrot();          parrot.name = "大鸚鵡";          parrot.parrotChild = parrotChild;          // 克隆          Parrot parrot2 = (Parrot) parrot.clone();          parrot2.name = "老鸚鵡";          parrot2.parrotChild.name = "少鸚鵡";          System.out.println("parrot name:" + parrot.name);          System.out.println("parrot child name:" + parrot.parrotChild.name);          System.out.println("parrot name 2:" + parrot2.name);          System.out.println("parrot child name 2:" + parrot2.parrotChild.name);      }   }  class Parrot implements Cloneable {      public String name;      public ParrotChild parrotChild;      @Override      protected Object clone() throws CloneNotSupportedException {          Parrot bird = (Parrot) super.clone();          bird.parrotChild = (ParrotChild) parrotChild.clone();          return bird;      }  }  class ParrotChild implements Cloneable {      public String name;      @Override      protected Object clone() throws CloneNotSupportedException {          return super.clone();      }  }

程式執行結果：

parrot name:大鸚鵡  parrot child name:小鸚鵡  parrot name 2:老鸚鵡  parrot child name 2:少鸚鵡

三、克隆相關面試題

1.使用克隆有什麼好處？

答：好處包含以下幾點：

使用方便：假如要複製一個對象，但這個對象中的部分屬性已經被修改過了，如果不使用克隆的話，需要給屬性手動賦值，相比克隆而已麻煩很多；
性能高：查看 clone 方法可以知道，它是 native 方法，native 方法是原生函數，使用作業系統底層的語言實現的，因此執行效率更高；
隔離性：克隆可以確保對象操作時相互隔離。

clone() 源程式碼，如下圖：

2.淺克隆和深克隆有什麼區別？

答：區別主要在對引用類型的複製上，具體資訊如下：

淺克隆：只會複製對象的值類型，而不會複製對象的引用類型；
深克隆：複製整個對象，包含值類型和引用類型。 3.如何實現淺克隆？答：克隆的對象實現 Cloneable 介面，並重寫 clone() 方法就可以實現淺克隆了。 4.以下程式碼執行的結果是？

import java.util.Arrays;  class CloneTest {      public static void main(String[] args) throws CloneNotSupportedException {          CloneObj cloneObj = new CloneObj();          cloneObj.name = "老王";          cloneObj.age = 30;          cloneObj.sistersAge = new int[]{18, 19};          CloneObj cloneObj2 = (CloneObj) cloneObj.clone();          cloneObj2.name = "磊哥";          cloneObj2.age = 33;          cloneObj2.sistersAge[0] = 20;          System.out.println(cloneObj.name + "|" + cloneObj2.name);          System.out.println(cloneObj.age + "|" + cloneObj2.age);          System.out.println(Arrays.toString(cloneObj.sistersAge) + "|" + Arrays.toString(cloneObj2.sistersAge));      }  }  class CloneObj implements Cloneable {      public String name;      public int age;      public int[] sistersAge;      @Override      protected Object clone() throws CloneNotSupportedException {          return super.clone();      }  }

答：執行結果如下。

老王|磊哥  30|33  [20, 19]|[20, 19]

5.深克隆如何實現？有幾種實現方式？

答：一般實現方式有以下兩種：

通過序列化實現深克隆（序列化實現方式：Java 原生序列化、JSON 序列化、Hessian 序列化）；
所有引用類型都實現克隆，從而實現深克隆。 6.為什麼不能直接使用 Object 的 Clone 方法，還要重寫 clone() 方法之後才能實現克隆？答：雖然所有類都是 Object 的子類，但因為 Object 中的 clone() 方法被聲明為 protected 訪問級別，所以非 java.lang 包下的其他類是不能直接使用的。因此要想實現克隆功能，就必須實現 Cloneable，並重寫 clone() 方法才行。 7.序列化可不可以實現深克隆？實現的原理是什麼？答：先將原對象序列化到記憶體的位元組流中，再從位元組流中反序列化出剛剛存儲的對象，這個新對象和原對象就不存在任何地址上的共享，這樣就實現了深克隆。四、總結調用 Object 類中的 clone() 方法默認是淺克隆，淺克隆只能複製值類型，不能複製引用類型，因此更多的場景下我們需要深克隆，深克隆通常的實現方式有兩種：序列化方式或把所有的引用類型都實現克隆。