深淺克隆面試題彙總——附詳細答案
在開始學習深克隆和淺克隆之前,我們先來看下面程式碼,有什麼問題?
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() 方法預設是淺克隆,淺克隆只能複製值型別,不能複製引用型別,因此更多的場景下我們需要深克隆,深克隆通常的實現方式有兩種:序列化方式或把所有的引用型別都實現克隆。
特別說明:本文來自《Java面試題全解析》