為了賬號安全,請及時綁定郵箱和手機立即綁定

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

2019.09.18 09:45 1092瀏覽

圖片描述
在開始學習深克隆和淺克隆之前,我們先來看下面代碼,有什么問題?

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:狗二

也就是說淺克隆,只會復制對象的值類型,而不會復制對象的引用類型。原因如下圖所示:
圖片描述
要處理引用類型不被復制的問題,就要使用到深克隆。

二、深克隆

定義:深克隆就是復制整個對象信息,包含值類型和引用類型。
深克隆的實現方式通常包含以下兩種。

  • 序列化實現深克?。合葘⒃瓕ο笮蛄谢絻却娴淖止澚髦?,再從字節流中反序列化出剛剛存儲的對象,這個新對象和原對象就不存在任何地址上的共享,這樣就實現了深克隆。
  • 所有引用類型都實現克?。阂獜椭茖ο蟮乃幸妙愋投家獙崿F克隆,所有對象都是復制的新對象,從而實現了深克隆。

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

實現思路:先將要拷貝對象寫入到內存中的字節流中,然后再從這個字節流中讀出剛剛存儲的信息,作為一個新對象返回,那么這個新對象和原對象就不存在任何地址上的共享,自然實現了深拷貝。請參考以下代碼:

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.深克隆如何實現?有幾種實現方式?

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

  • 通過序列化實現深克?。ㄐ蛄谢瘜崿F方式:Java 原生序列化、JSON 序列化、Hessian 序列化);
  • 所有引用類型都實現克隆,從而實現深克隆。

6.為什么不能直接使用 Object 的 Clone 方法,還要重寫 clone() 方法之后才能實現克???

答:雖然所有類都是 Object 的子類,但因為 Object 中的 clone() 方法被聲明為 protected 訪問級別,所以非 java.lang 包下的其他類是不能直接使用的。因此要想實現克隆功能,就必須實現 Cloneable,并重寫 clone() 方法才行。

7.序列化可不可以實現深克???實現的原理是什么?

答:先將原對象序列化到內存的字節流中,再從字節流中反序列化出剛剛存儲的對象,這個新對象和原對象就不存在任何地址上的共享,這樣就實現了深克隆。

四、總結

調用 Object 類中的 clone() 方法默認是淺克隆,淺克隆只能復制值類型,不能復制引用類型,因此更多的場景下我們需要深克隆,深克隆通常的實現方式有兩種:序列化方式或把所有的引用類型都實現克隆。


特別說明:本文來自《Java面試題全解析》

點擊查看更多內容

本文首次發布于慕課網 ,轉載請注明出處,謝謝合作

2人點贊

若覺得本文不錯,就分享一下吧!

評論

相關文章推薦

正在加載中
意見反饋 幫助中心 APP下載
官方微信

舉報

0/150
提交
取消
开奖号码