content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,java,深拷贝,浅拷贝

  • 2022-11-06
  • 浏览 (539)

title: 一文彻底讲明白的Java中的浅拷贝与深拷贝 shortTitle: Java中的浅拷贝与深拷贝 category: - Java核心 tag: - Java重要知识点 description: Java程序员进阶之路，小白的零基础Java教程，从入门到进阶，一文彻底讲明白的Java中的浅拷贝与深拷贝 head: - - meta - name: keywords

content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,java,深拷贝,浅拷贝

“哥，听说浅拷贝和深拷贝是 Java 面试中经常会被问到的一个问题，是这样吗？”

“还真的是，而且了解浅拷贝和深拷贝的原理，对 Java 是值传递还是引用传递也会有更深的理解。”我肯定地回答。

“不管是浅拷贝还是深拷贝，都可以通过调用 Object 类的 clone() 方法来完成。”我一边说，一边打开 Intellij IDEA，并找到了 clone() 方法的源码。

@HotSpotIntrinsicCandidate
protected native Object clone() throws CloneNotSupportedException;

其中 @HotSpotIntrinsicCandidate 是 Java 9 引入的一个注解，被它标注的方法，在 HotSpot 虚拟机中会有一套高效的实现。需要注意的是，clone() 方法同时是一个本地（native）方法，它的具体实现会交给 HotSpot 虚拟机，那就意味着虚拟机在运行该方法的时候，会将其替换为更高效的 C/C++ 代码，进而调用操作系统去完成对象的克隆工作。

“哥，那你就先说浅拷贝吧！”

“好的呀。直接上实战代码。”

class Writer implements Cloneable{
    private int age;
    private String name;

    // getter/setter 和构造方法都已省略

    @Override
    public String toString() {
        return super.toString().substring(26) + "{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

Writer 类有两个字段，分别是 int 类型的 age，和 String 类型的 name。然后重写了 toString() 方法，方便打印对象的具体信息。

“为什么要实现 Cloneable 接口呢？”三妹开启了十万个为什么的模式。

Cloneable 接口是一个标记接口，它肚子里面是空的：

public interface Cloneable {
}

只是，如果一个类没有实现 Cloneable 接口，即便它重写了 clone() 方法，依然是无法调用该方法进行对象克隆的，程序在执行 clone() 方法的时候会抛出 CloneNotSupportedException 异常。

Exception in thread "main" java.lang.CloneNotSupportedException

标记接口的作用其实很简单，用来表示某个功能在执行的时候是合法的。

“哦，我悟了！”三妹看来是彻底明白了我说的内容。

“接着，来测试类。”

class TestClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Writer writer1 = new Writer(18,"二哥");
        Writer writer2 = (Writer) writer1.clone();

        System.out.println("浅拷贝后：");
        System.out.println("writer1：" + writer1);
        System.out.println("writer2：" + writer2);

        writer2.setName("三妹");

        System.out.println("调整了 writer2 的 name 后：");
        System.out.println("writer1：" + writer1);
        System.out.println("writer2：" + writer2);
    }
}
  • 通过 new 关键字声明了一个 Writer 对象（18 岁的二哥），将其赋值给 writer1。
  • 通过调用 clone() 方法进行对象拷贝，并将其赋值给 writer2。
  • 之后打印 writer1 和 writer2。
  • 将 writer2 的 name 字段调整为“三妹”。
  • 再次打印。

来看一下输出结果。

浅拷贝后：
writer1：Writer@68837a77{age=18, name='二哥'}
writer2：Writer@b97c004{age=18, name='二哥'}
调整了 writer2 的 name 后：
writer1：Writer@68837a77{age=18, name='二哥'}
writer2：Writer@b97c004{age=18, name='三妹'}

可以看得出，浅拷贝后，writer1 和 writer2 引用了不同的对象，但值是相同的，说明拷贝成功。之后，修改了 writer2 的 name 字段，直接上图就明白了。

之前的例子中，Writer 类只有两个字段，没有引用类型字段。那么，我们再来看另外一个例子，为 Writer 类增加一个自定义的引用类型字段 Book，先来看 Book 的定义。

class Book {
    private String bookName;
    private int price;

    // getter/setter 和构造方法都已省略

    @Override
    public String toString() {
        return super.toString().substring(26) +
                " bookName='" + bookName + '\'' +
                ", price=" + price +
                '}';
    }
}

有两个字段，分别是 String 类型的 bookName 和 int 类型的 price。

然后来看 Writer 类的定义。

class Writer implements Cloneable{
    private int age;
    private String name;
    private Book book;

    // getter/setter 和构造方法都已省略

    @Override
    public String toString() {
        return super.toString().substring(26) +
                " age=" + age +
                ", name='" + name + '\'' +
                ", book=" + book +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

比之前的例子多了一个自定义类型的字段 book，clone() 方法并没有任何改变。

再来看测试类。

class TestClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Writer writer1 = new Writer(18,"二哥");
        Book book1 = new Book("编译原理",100);
        writer1.setBook(book1);

        Writer writer2 = (Writer) writer1.clone();
        System.out.println("浅拷贝后：");

        System.out.println("writer1：" + writer1);
        System.out.println("writer2：" + writer2);

        Book book2 = writer2.getBook();
        book2.setBookName("永恒的图灵");
        book2.setPrice(70);
        System.out.println("writer2.book 变更后：");

        System.out.println("writer1：" + writer1);
        System.out.println("writer2：" + writer2);
    }
}
  • 通过 new 关键字声明了一个 Writer 对象（18 岁的二哥），将其赋值给 writer1。
  • 通过 new 关键字声明了一个 Book 对象（100 块的编译原理），将其赋值给 book1。
  • 将 writer1 的 book 字段设置为 book1。
  • 通过调用 clone() 方法进行对象拷贝，并将其赋值给 writer2。
  • 之后打印 writer1 和 writer2。
  • 获取 writer2 的 book 字段，并将其赋值给 book2。
  • 将 book2 的 bookName 字段调整为“永恒的图灵”，price 字段调整为 70。
  • 再次打印。

来看一下输出结果。

浅拷贝后：
writer1：Writer@68837a77 age=18, name='二哥', book=Book@32e6e9c3 bookName='编译原理', price=100}}
writer2：Writer@6d00a15d age=18, name='二哥', book=Book@32e6e9c3 bookName='编译原理', price=100}}
writer2.book 变更后：
writer1：Writer@68837a77 age=18, name='二哥', book=Book@32e6e9c3 bookName='永恒的图灵', price=70}}
writer2：Writer@36d4b5c age=18, name='二哥', book=Book@32e6e9c3 bookName='永恒的图灵', price=70}}

与之前例子不同的是，writer2.book 变更后，writer1.book 也发生了改变。这是因为字符串 String 是不可变对象，一个新的值必须在字符串常量池中开辟一段新的内存空间，而自定义对象的内存地址并没有发生改变，只是对应的字段值发生了改变，见下图。

“哇，哥，果真一图胜千言，我明白了。”三妹似乎对我画的图很感兴趣呢，“那你继续说深拷贝吧！”

“嗯，三妹，你有没有注意到，浅拷贝克隆的对象中，引用类型的字段指向的是同一个，当改变任何一个对象，另外一个对象也会随之改变，除去字符串的特殊性外。”

“深拷贝和浅拷贝不同的，深拷贝中的引用类型字段也会克隆一份，当改变任何一个对象，另外一个对象不会随之改变。”

“明白了这一点后，我们再来看例子。”

class Book implements Cloneable{
    private String bookName;
    private int price;

    // getter/setter 和构造方法都已省略

    @Override
    public String toString() {
        return super.toString().substring(26) +
                " bookName='" + bookName + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

注意，此时的 Book 类和浅拷贝时不同，重写了 clone() 方法，并实现了 Cloneable 接口。为的就是深拷贝的时候也能够克隆该字段。

class Writer implements Cloneable{
    private int age;
    private String name;
    private Book book;

    // getter/setter 和构造方法都已省略

    @Override
    public String toString() {
        return super.toString().substring(26) +
                " age=" + age +
                ", name='" + name + '\'' +
                ", book=" + book +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Writer writer = (Writer) super.clone();
        writer.setBook((Book) writer.getBook().clone());
        return writer;
    }
}

注意，此时 Writer 类也与之前的不同，clone() 方法当中，不再只调用 Object 的 clone() 方法对 Writer 进行克隆了，还对 Book 也进行了克隆。

来看测试类。

class TestClone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Writer writer1 = new Writer(18,"二哥");
        Book book1 = new Book("编译原理",100);
        writer1.setBook(book1);

        Writer writer2 = (Writer) writer1.clone();
        System.out.println("深拷贝后：");

        System.out.println("writer1：" + writer1);
        System.out.println("writer2：" + writer2);

        Book book2 = writer2.getBook();
        book2.setBookName("永恒的图灵");
        book2.setPrice(70);
        System.out.println("writer2.book 变更后：");

        System.out.println("writer1：" + writer1);
        System.out.println("writer2：" + writer2);
    }
}

这个测试类和之前的浅拷贝的测试类就完全一样了，但运行结果是不同的。

深拷贝后：
writer1：Writer@6be46e8f age=18, name='二哥', book=Book@5056dfcb bookName='编译原理', price=100}}
writer2：Writer@6d00a15d age=18, name='二哥', book=Book@51efea79 bookName='编译原理', price=100}}
writer2.book 变更后：
writer1：Writer@6be46e8f age=18, name='二哥', book=Book@5056dfcb bookName='编译原理', price=100}}
writer2：Writer@6d00a15d age=18, name='二哥', book=Book@51efea79 bookName='永恒的图灵', price=70}}

不只是 writer1 和 writer2 是不同的对象，它们中的 book 也是不同的对象。所以，改变了 writer2 中的 book 并不会影响到 writer1。

不过，通过 clone() 方法实现的深拷贝比较笨重，因为要将所有的引用类型都重写 clone() 方法，当嵌套的对象比较多的时候，就废了！

“那有没有好的办法呢？”三妹急切的问。

“当然有了，利用序列化。”我胸有成竹的回答，“序列化是将对象写到流中便于传输，而反序列化则是将对象从流中读取出来。”

“写入流中的对象就是对原始对象的拷贝。需要注意的是，每个要序列化的类都要实现 Serializable 接口，该接口和 Cloneable 接口类似，都是标记型接口。”

来看例子。

class Book implements Serializable {
    private String bookName;
    private int price;

    // getter/setter 和构造方法都已省略

    @Override
    public String toString() {
        return super.toString().substring(26) +
                " bookName='" + bookName + '\'' +
                ", price=" + price +
                '}';
    }
}

Book 需要实现 Serializable 接口。

class Writer implements Serializable {
    private int age;
    private String name;
    private Book book;

    // getter/setter 和构造方法都已省略

    @Override
    public String toString() {
        return super.toString().substring(26) +
                " age=" + age +
                ", name='" + name + '\'' +
                ", book=" + book +
                '}';
    }

    //深度拷贝
    public Object deepClone() throws IOException, ClassNotFoundException {
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(this);

        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);

        return ois.readObject();
    }
}

Writer 类也需要实现 Serializable 接口，并且在该类中，增加了一个 deepClone() 的方法，利用 OutputStream 进行序列化，InputStream 进行反序列化，这样就实现了深拷贝。

来看示例。

class TestClone {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Writer writer1 = new Writer(18,"二哥");
        Book book1 = new Book("编译原理",100);
        writer1.setBook(book1);

        Writer writer2 = (Writer) writer1.deepClone();
        System.out.println("深拷贝后：");

        System.out.println("writer1：" + writer1);
        System.out.println("writer2：" + writer2);

        Book book2 = writer2.getBook();
        book2.setBookName("永恒的图灵");
        book2.setPrice(70);
        System.out.println("writer2.book 变更后：");

        System.out.println("writer1：" + writer1);
        System.out.println("writer2：" + writer2);
    }
}

与之前测试类不同的是，调用了 deepClone() 方法。

深拷贝后：
writer1：Writer@9629756 age=18, name='二哥', book=Book@735b5592 bookName='编译原理', price=100}}
writer2：Writer@544fe44c age=18, name='二哥', book=Book@31610302 bookName='编译原理', price=100}}
writer2.book 变更后：
writer1：Writer@9629756 age=18, name='二哥', book=Book@735b5592 bookName='编译原理', price=100}}
writer2：Writer@544fe44c age=18, name='二哥', book=Book@31610302 bookName='永恒的图灵', price=70}}

测试结果和之前用 clone() 方法实现的深拷贝类似。

“不过，三妹，需要注意，由于是序列化涉及到输入流和输出流的读写，在性能上要比 HotSpot 虚拟机实现的 clone() 方法差很多。”我语重心长地说。

“好的，二哥，你先去休息吧，让我来琢磨一会，总结一下浅拷贝和深拷贝之间的差异。”

“嗯嗯。”

你可能感兴趣的文章

content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,Java保留字,Java关键字,关键字,保留字

content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,java,重写,Overriding

content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,java,注解,annotation

content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,装箱,拆箱,包装类型

content: Java,Java SE,Java基础,Java教程,Java程序员进阶之路,Java入门,教程,java,class,object

0  赞
  • 所属分类： 后端技术
  • 本文标签： Java
  • 版权声明： 原创文章如转载，请注明本文链接: https://m.seaxiang.com/blog/9a0573f33d6e4fd094302dd3ae7f6914
热门推荐
标签云
Linux Java Spring Spring Boot docker 大数据 前端 生活 maven golang 软件 spring cloud fintech mac vscode 其他 区块链 以太坊 V神 开发者 技术 股票 git greenplum 分布式事务 chrome mysql flink kafka 设计模式 原理 鸿蒙 seo
最新文章
本文目录