java基础总结(二十四)--深克隆与浅克隆

最新推荐文章于 2023-12-25 10:53:12 发布
最新推荐文章于 2023-12-25 10:53:12 发布
阅读量163 收藏 1
点赞数
分类专栏： java基础总结 文章标签： 深克隆与浅克隆
原文链接：https://www.cnblogs.com/BonnieWss/p/10911697.html
版权

本文内容来自https://www.cnblogs.com/acode/p/6306887.html

Java中要想自定义类的对象可以被复制，自定义类就必须实现Cloneable中的clone()方法，如下：

public class Student implements Cloneable {
    
    private String name;
    
    private int age;
    
    private Professor professor;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Professor getProfessor() {
        return professor;
    }

    public void setProfessor(Professor professor) {
        this.professor = professor;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", professor="
                + professor + "]";
    }
    
    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }

}

其中，Professor类同样为自定义类：

public class Professor {

    private String name;

    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Professor [name=" + name + ", age=" + age + "]";
    }

}

然而，当自定义类的字段的类型不是基本数据类型时，上面实现了clone()方法会导致问题，不信看下面的代码：

【程序实例1】

public class ShadowCopy {

    public static void main(String[] args) {
        Professor p1 = new Professor();
        p1.setName("Professor Zhang");
        p1.setAge(30);

        Student s1 = new Student();
        s1.setName("xiao ming");
        s1.setAge(18);
        s1.setProfessor(p1);

        System.out.println(s1);

        try {
            Student s2 = (Student) s1.clone();
            Professor p2 = s2.getProfessor();
            p2.setName("Professor Li");
            p2.setAge(45);
            s2.setProfessor(p2);
            System.out.println("复制后的：s1 = " + s1);
            System.out.println("复制后的：s2 = " + s2);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }

}

【运行结果1】

1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]]
2 复制后的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]]
3 复制后的：s2 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]]

【结果分析】

学生s1的导师为30岁的Professor Zhang，恰好学生s2与学生s1同名同岁，但是s2的导师为45岁的Professor Li，于是我们顺理成章地复制复制s1并复制给s2，再修改下s2的导师的信息。可是，问题出现了，当我们修改了s2的导师后，s2的信息是对了，但是s1的导师信息也跟着修改了，这可不是我们期望的。

【问题分析】

程序实例1中的问题出在哪儿呢？我们已经对Student类实现了clone()方法，怎么还是出问题了呢？我们在看下面的代码：

【程序实例2】

public class ShadowCopy {

    public static void main(String[] args) {
        Professor p1 = new Professor();
        p1.setName("Professor Zhang");
        p1.setAge(30);

        Student s1 = new Student();
        s1.setName("xiao ming");
        s1.setAge(18);
        s1.setProfessor(p1);

        System.out.println(s1);

        try {
            Student s2 = (Student) s1.clone();
            s2.setName("xiao hong");
            s2.setAge(17);
            Professor p2 = s2.getProfessor();
            p2.setName("Professor Li");
            p2.setAge(45);
            s2.setProfessor(p2);
            System.out.println("复制后的：s1 = " + s1);
            System.out.println("复制后的：s2 = " + s2);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }

}

【运行结果】

1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]]
2 复制后的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Li, age=45]]
3 复制后的：s2 = Student [name=xiao hong, age=17, professor=Professor [name=Professor Li, age=45]]

【结果分析】

这次，我们在clone后，又修改了s2的name和age，从结果可以看出，s1的name和age并没有因为s2的修改而改变。

 

结合程序实例1和程序实例2，我们发现Student的字段如果不是一个引用时，修改clone()得到对象的该字段(name, age)时并不会影响原来的对象，但是当字段为一个引用时，修改clone()得到对象的该字段(professor)时并会影响原来的对象。上面实现的clone()方法为浅复制（shadow copy）。

 

如果想要clone()得到的新对象的修改不会影响被复制的对象的字段时，我们就需要实现深复制（deep copy），代码修改如下：

public class Professor implements Cloneable {

    private String name;

    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Professor [name=" + name + ", age=" + age + "]";
    }

    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }

}
public class Student implements Cloneable {
    
    private String name;
    
    private int age;
    
    private Professor professor;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Professor getProfessor() {
        return professor;
    }

    public void setProfessor(Professor professor) {
        this.professor = professor;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", professor="
                + professor + "]";
    }
    
    public Object clone() throws CloneNotSupportedException{
        Student newStudent = (Student) super.clone();
        newStudent.professor = (Professor) professor.clone();
        return newStudent;
    }

}

再次运行【程序实例2】得到的结果为：

1 Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]]
2 复制后的：s1 = Student [name=xiao ming, age=18, professor=Professor [name=Professor Zhang, age=30]]
3 复制后的：s2 = Student [name=xiao hong, age=17, professor=Professor [name=Professor Li, age=45]]

可以看到：修改clone()得到的s2的任何字段都不会影响s1的字段，这也就是深复制的作用。

 

使用流来进行深克隆

使用流来进行深克隆的原文：https://www.cnblogs.com/BonnieWss/p/10911697.html

public class Test implements Serializable {
    private Entity entity;

    public Entity getEntity() {
        return entity;
    }

    public void setEntity(Entity entity) {
        this.entity = entity;
    }


    /**
     * 先将类实现序列化接口，将类写入流再读出，实际上是实现了类的深克隆
     * @throws Exception
     */
    public void writeAndReadObject() throws Exception {
        Entity entity = new Entity();
        entity.setS("111");
        Test test = new Test();
        test.setEntity(entity);
        //将对象写入流
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(test);

        //从流中读对象
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        Test t = (Test) objectInputStream.readObject();

        System.out.println(test.getClass() == t.getClass());//true
        System.out.println(test.getEntity()==t.getEntity());//false
        System.out.println(test.getEntity().getS().equals(t.getEntity().getS()));//true

    }

    public static void main(String[] args) throws Exception {
        Test test = new Test();
        test.writeAndReadObject();
    }
}
public class Entity implements Serializable {
    private String s;

    public String getS() {
        return s;
    }

    public void setS(String s) {
        this.s = s;
    }
}

 

 

参考资料：

1、http://pengcqu.iteye.com/blog/493120

2、http://www.cnblogs.com/shuaiwhu/archive/2010/12/14/2065088.html

也可以参考https://jingyan.baidu.com/article/4853e1e557f84a1908f72673.html

秋天的猿
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实例分析java对象中浅克隆和深克隆
08-26
浅克隆和深克隆在Java对象中的应用 在Java编程语言中，克隆（Clone）是一种常见的对象复制机制。克隆可以分为浅克隆（Shallow Clone）和深克隆（Deep Clone）两种。浅克隆仅复制对象的引用，而深克隆则完全复制对象...
java 对象的克隆（浅克隆和深克隆）
08-29
总结起来，Java对象的克隆机制是创建对象副本的一种手段，分为浅克隆和深克隆。浅克隆只复制对象的基本类型字段，而引用字段指向的是原始对象的引用。深克隆则会递归地复制所有字段，包括引用类型的字段，确保副本与...
JAVA中浅复制与深复制
popkiler的专栏
09-27 747
 JAVA中浅复制与深复制　　1．浅复制与深复制概念　　⑴浅复制（浅克隆）　　被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。　　⑵深复制（深克隆）　　被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的
Java中的深复制和浅复制
EvinK的博客
08-10 939
约在7万多年前，我们的智人祖先经历了一场所谓的”认知革命”。这场革命就像是一把钥匙，打开了潘多拉的魔盒，人类的对于虚构世界的脑洞从此一开不可收拾。同人类其他众多的幻想一样，对人事物的“复制“的这一虚构臆想，推进了文明的演进，直接或间接地催促了艺术这种文化形态的繁荣。 而现今，随着各种终端的普及，”复制“这个词也随着互联网一起传播出去。无论是你每天在电脑里使用ctrl+c和ctr...
Java 引用的复制，深复制和浅复制之间的区别 一篇就够了
胃病的不良少彦
09-28 1510
复制对象 两个对象的引用相同，都指向同一个对象，叫引用的复制 只有一个对象，只不过是两个引用指向同一个对象 Person p = new Person(23, "zhang"); Person p1 = p; System.out.println(p ==p1); //true 无论深复制还是浅复制都会新创建一个对象 什么是浅复制？ 3. 代码实例： 其中Student实现Cloneabl...
java的深复制浅复制_Java中的深拷贝(深复制)和浅拷贝(浅复制)
weixin_42628464的博客
02-21 130
深拷贝(深复制)和浅拷贝(浅复制)是两个比较通用的概念，尤其在C++语言中，若不弄懂，则会在delete的时候出问题，但是我们在这幸好用的是Java。虽然java自动管理对象的回收，但对于深拷贝(深复制)和浅拷贝(浅复制)，我们还是要给予足够的重视，因为有时这两个概念往往会给我们带来不小的困惑。浅拷贝是指拷贝对象时仅仅拷贝对象本身(包括对象中的基本变量)，而不拷贝对象包含的引用指向的对象。深拷贝不...
java中的深拷贝和浅拷贝
mada26
02-26 411
对象拷贝(Object Copy)就是将一个对象的属性拷贝到另一个有着相同类类型的对象中去。在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用对象的部分或全部数据。Java中有三种类型的对象拷贝：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)、延迟拷贝(Lazy Copy)。 1：浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精
java 深克隆 浅克隆
11-28
在Java编程语言中，克隆是...理解深克隆和浅克隆的概念对于编写复杂的、性能敏感的Java程序至关重要，尤其是在处理大量对象或需要保持数据独立性时。根据具体需求选择合适的克隆策略，可以提高代码的灵活性和可维护性。
浅析Java中clone()方法浅克隆与深度克隆
08-30
在Java中，克隆分为两种类型：浅克隆（Shallow Clone）和深度克隆（Deep Clone）。 1. 浅克隆（Shallow Clone） 浅克隆是Java克隆机制的默认行为。当一个对象被克隆时，如果它的成员变量是基本类型（如int、double...
java 深克隆与浅克隆
09-11
Java 深克隆与浅克隆 Java 中的克隆机制可以让我们方便地制造出一个对象的副本来，但是在克隆过程中需要注意浅克隆和深克隆的区别。 浅克隆（Shallow Clone）是指对对象的域进行简单的 copy，对象的reference变量...
java中的深拷贝与浅拷贝
bohu83的博客
06-29 478
一 序  最初这篇打算放在arraylist里面整理，因为arraylist也是实现了clone接口。想想还是摘出来吧public interface Cloneable { }关于clone，就是复制。它允许在堆中克隆出一块和原对象一样的对象，并将这个对象的地址赋予新的引用。 Java 中 一个类要实现clone功能 必须实现 Cloneable接口，否则在调用 clone() 时会报 Clon...
java深拷贝和浅拷贝
xinhunhai的专栏
10-06 228
Java对象的深复制和浅复制
Java深拷贝与浅拷贝
Harper_1205的博客
04-14 1886
一、引入 1）引用拷贝 指创建一个指向对象的引用变量的拷贝。代码如下： 它的输出结果： 由此可见，c和newC他们的地址是相同的，那他们引用了同一个对象。他们都指向了对象Children(“111”,18)。这叫引用拷贝。 2）对象拷贝 创建一个对象本身的副本。 代码如下： 输出结果如下： ...
对Java中的深复制和浅复制的一些理解
Megustas_JJC的博客
08-10 602
Java语言的一个优点就是取消了指针的概念，但也导致了许多程序员在编程中常常忽略了对象与引用的区别，本文会试图澄清这一概念。并且由于Java不能通过简单的赋值来解决对象复制的问题，在开发过程中，也常常要要应用clone（）方法来复制对象。浅复制与深复制概念浅复制（浅克隆） ：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象
一文道破Java中的深拷贝，浅拷贝，零拷贝
最新发布
小威的博客
12-25 1万+
在Java编写代码中，对象的拷贝是一个常见的操作。根据拷贝的层次和方式不同，可以分为深拷贝、浅拷贝和零拷贝。本篇文章我们将详细介绍这三种拷贝方式的概念、实现方法以及使用场景，方便大佬学习及面试。
java中的浅复制和深复制
haidi8
11-17 601
浅复制：只复制基本数据类型，对于引用类型不能实现浅复制的效果。 代码： package com.qf.day13.price.object; public class TestObject { public static void main(String[] args) { Student stu1 = new Student("张三",22); stu1.name="李四"; System.out.println(stu1); Student stu2 =(Student) stu1.c
浅谈Java中的浅复制和深复制
weixin_38810239的博客
03-10 4835
浅谈Java中的浅克隆和深克隆1-clone、Cloneable和Serialiable什么是浅复制？什么是深复制？两者有何区别？要弄清楚这些问题，一切都要从Object的一个方法clone方法和两个标记接口Cloneable和Serializable谈起！首先来看看clone方法，clone方法是Java中根父类Object的一个方法，定义如下：protected native Object c...
Java浅复制和深复制
weixin_44416759的博客
07-12 235
浅复制就是复制对象中的基本数据类型，但对于对象中的引用类型只复制其引用；深复制则是不止复制对象中的基本数据类型，而且复制对象中的引用指向的所有对象。 Java中要实现深复制，可以先使对象实现Serializable接口，然后把对象写到一个流里，再从流里读出来重建对象。（常见的深复制实现）。 需要注意的是，代码中不仅Person类要实现Serializable接口，它内部的School类也要实现Serializable接口。 public class deepCopy { public static
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值