专栏首页王磊的博客深浅克隆面试题汇总——附详细答案

深浅克隆面试题汇总——附详细答案

在开始学习深克隆和浅克隆之前,我们先来看下面代码,有什么问题?

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() 方法默认是浅克隆,浅克隆只能复制值类型,不能复制引用类型,因此更多的场景下我们需要深克隆,深克隆通常的实现方式有两种:序列化方式或把所有的引用类型都实现克隆。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • PL/SQL Developer中文版下载以及使用图解(绿色版)

    下载地址:http://pan.baidu.com/s/1eQCTmkM 1、运行plsqldev.exe程序; 2、设置Oracle主目录名/OCI库地址,如...

    Java中文社群_老王
  • NVelocity标签使用详解

    本文使用的NVelocity版本为1.1.1,应该是目前为止最新的版本吧,前几天在google上找了一个自称是NVelocity 1.6.1 bate2的dll...

    Java中文社群_老王
  • netframework 4.0内置处理JSON对象

    前言 必须的是 .netframewoke 4.0的项目才能使用。 内容 1.项目添加System.Runtime.Serialization引用。 2.Jso...

    Java中文社群_老王
  • python中的内置函数(双下划线) 原

    如果我们是直接执行某个.py文件的时候,该文件中那么”__name__ == '__main__'“是True,但是我们如果从另外一个.py文件通过import...

    晓歌
  • Python+Selenium 技巧篇-svg标签内元素的xpath定位方式

    这种元素比较特殊,需要通过 name 属性来进行定位。 写法如下: //*[name()="svg"]//*[name()="image"]

    小蓝枣
  • bug诞生记——临时变量、栈变量导致的双杀

            这是《bug诞生记》的第一篇文章。本来想起个文艺点的名字,比如《Satan(撒旦)来了》,但是最后还是想让这系列的重心放在“bug的产生过程”和...

    方亮
  • tekton入门-trigger

    trigger使用户能够将事件有效负载中的字段映射到资源模板中。换句话说,这允许事件既可以建模也可以将实例化为Kubernetes资源。对于tektoncd/p...

    有点技术
  • Android的Wifi连接

    最近在做Wifi连接的功能,在网上查找了很多资料,可用的也比较少,最后遇到很多了问题,一路走来也解决了很多问题,特此记录。

    None_Ling
  • Python Redis

      NoSQL(NoSQL = Not Only SQL ),意即“不仅仅是SQL”,是一项全新的数据库革命性运动,泛指非关系型的数据库。随着互联网web2.0...

    py3study
  • RabbitMq的消息队列类型direct、fanout、topic、headers(headers抛弃)

    1 服务端 server 将 消息 msg_txt 投递 到 交换器 exchange_name 路由键为 routing_key_name ,当 有队列 qu...

    93年的老男孩

扫码关注云+社区

领取腾讯云代金券