java 深克隆（深拷贝）与浅克隆（拷贝）详解

最新推荐文章于 2024-08-27 10:25:50 发布
最新推荐文章于 2024-08-27 10:25:50 发布
阅读量165 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ht941991/article/details/93627790
版权

java深克隆和浅克隆

基本概念

  1. 浅复制(浅克隆)

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所拷贝的对象，而不复制它所引用的对象。

  1. 深复制(深克隆)

    被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

实现java深复制和浅复制的最关键的就是要实现Object中的clone()方法。

如何使用clone()方法

首先我们来看一下Cloneable接口：

官方解释：

1：实现此接口则可以使用java.lang.Object 的clone()方法，否则会抛出CloneNotSupportedException 异常

2：实现此接口的类应该使用公共方法覆盖clone方法

3：此接口并不包含clone 方法，所以实现此接口并不能克隆对象，这只是一个前提，还需覆盖上面所讲的clone方法。

public interface Cloneable {
}

看看Object里面的Clone()方法：

  1. clone()方法返回的是Object类型，所以必须强制转换得到克隆后的类型
  2. clone()方法是一个native方法，而native的效率远远高于非native方法，
  3. 可以发现clone方法被一个Protected修饰，所以可以知道必须继承Object类才能使用，而Object类是所有类的基类，也就是说所有的类都可以使用clone方法
protected native Object clone() throws CloneNotSupportedException;

小试牛刀：

public class Person {
    public void testClone(){
        super.clone(); // 报错了
    }
}

事实却是clone()方法报错了，那么肯定奇怪了，既然Object是一切类的基类，并且clone的方法是Protected的，那应该是可以通过super.clone()方法去调用的，然而事实却是会抛出CloneNotSupportedException异常, 官方解释如下：

  1. 对象的类不支持Cloneable接口
  2. 覆盖方法的子类也可以抛出此异常表示无法克隆实例。

所以我们更改代码如下：

public class Person implements Cloneable{
    public void testClone(){
        try {
            super.clone();
            System.out.println("克隆成功");
        } catch (CloneNotSupportedException e) {
            System.out.println("克隆失败");
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Person p = new Person();
        p.testClone();
    }
}

要注意，必须将克隆方法写在try-catch块中，因为clone方法会把异常抛出，当然程序也要求我们try-catch。

java.lang.object规范中对clone方法的约定

  1. 对任何的对象x，都有x.clone() !=x 因为克隆对象与原对象不是同一个对象
  2. 对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
  3. 如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立

对于以上三点要注意，这3项约定并没有强制执行，所以如果用户不遵循此约定，那么将会构造出不正确的克隆对象，所以根据effective java的建议：

谨慎的使用clone方法，或者尽量避免使用。

浅复制实例

  1. 对象中全部是基本类型
public class Teacher implements Cloneable{
    private String name;
    private int age;

    public Teacher(String name, int age){
        this.name = name;
        this.age = age;
    }
    // 覆盖
    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
    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 class test {
    Teacher origin = new Teacher("tony", 11);
    System.out.println(origin.getName());
    Teacher clone = (Teacher) origin.clone();
    clone.setName("clone");
    System.out.println(origin.getName());
    System.out.println(clone.getName());
}

结果：

tony
tony
clone

从运行结果和图上可以知道，克隆后的值变量会开辟新的内存地址，克隆对象修改值不会影响原来对象。

  1. 对象中含有引用类型
public class Teacher implements Cloneable{
    private String name;
    private int age;
    private Student student;

    public Teacher(String name, int age, Student student){
        this.name = name;
        this.age = age;
        this.student = student;
    }
    // 覆盖
    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
    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 Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
}

// 学生类
public class Student {
    private String name;
    private int age;
    public Student(String name, int age){
        this.name = name;
        this.age = 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;
    }
}
// 客户端测试
public class test {
    public static void main(String[] args) {
        Student student = new Student("学生1" ,11);
        Teacher origin = new Teacher("老师", 11, student);;
        Teacher clone = (Teacher) origin.clone();
        System.out.println("比较克隆后的引用对象");
        System.out.println(origin.getStudent().getClass() == clone.getStudent().getClass());
        Student student2 = new Student("学生2", 12);
        clone.setStudent(student2);
        System.out.println("克隆后，比较克隆对象改变引用");
        System.out.println(origin.getStudent().getClass() == clone.getStudent().getClass());
    }
}

运行结果：

比较克隆后的引用对象
true
克隆后，比较克隆对象改变引用
true

如图可知，引用类型只会存在一份内存地址，执行object的clone方法拷贝的也是引用的复制（这部分的内存空间不一样，）但是引用指向的内存空间是一样的，原对象修改引用变量或者浅拷贝对象修改引用变量都会引起双方的变化

重点：综上两个方面可以知道，Object的clone方法是属于浅拷贝，基本变量类型会复制相同值，而引用变量类型也是会复制相同的引用。

深复制实例

从上面的浅拷贝可以知道，对于引用的变量只会拷贝引用指向的地址，也就是指向同一个内存地址，但是很多情况下我们需要的是下面图的效果：

深拷贝实现的是对所有可变(没有被final修饰的引用变量)引用类型的成员变量都开辟内存空间所以一般深拷贝对于浅拷贝来说是比较耗费时间和内存开销的。

深拷贝的两种方式：

  1. 重写clone方法实现深拷贝

学生类：

public class Student implements Cloneable {
    private String name;
    private int age;
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone()  {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

    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 class Teacher implements Cloneable{
    private String name;
    private int age;
    private Student student;

    public Teacher(String name, int age, Student student){
        this.name = name;
        this.age = age;
        this.student = student;
    }
    // 覆盖
    @Override
    public Object clone() {
        Teacher t = null;
        try {
            t = (Teacher) super.clone();
            t.student = (Student)student.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return t;
    }
    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 Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
}

测试端：

public class test {
    public static void main(String[] args) {
        Student s = new Student("学生1", 11);
        Teacher origin = new Teacher("老师原对象", 23, s);
        System.out.println("克隆前的学生姓名：" + origin.getStudent().getName());
        Teacher clone = (Teacher) origin.clone();
        // 更改克隆后的学生信息 更改了姓名
        clone.getStudent().setName("我是克隆对象更改后的学生2");
        System.out.println("克隆后的学生姓名：" + clone.getStudent().getName());
    }
}

运行结果：

克隆前的学生姓名：学生1
克隆后的学生姓名：我是克隆对象更改后的学生2

  1. 序列化实现深克隆

我们发现上面通过object的clone方法去实现深克隆十分麻烦， 因此引出了另外一种方式：序列化实现深克隆。

概念：

  • 序列化：把对象写到流里
  • 反序列化：把对象从流中读出来

在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。

注意：

  • 写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。
  • 对象以及对象内部所有引用到的对象都是可序列化的
  • 如果不想序列化，则需要使用transient来修饰

案例：

Teacher:

public class Teacher implements Serializable{
    private String name;
    private int age;
    private Student student;

    public Teacher(String name, int age, Student student){
        this.name = name;
        this.age = age;
        this.student = student;
    }
    // 深克隆
    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();
    }
    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 Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

Student:

public class Student implements Serializable {
    private String name;
    private int age;
    public Student(String name, int age){
        this.name = name;
        this.age = 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;
    }
}

client：

public class test {
    public static void main(String[] args) {
        try {
            Student s = new Student("学生1", 11);
            Teacher origin = new Teacher("老师原对象", 23, s);
            System.out.println("克隆前的学生姓名：" + origin.getStudent().getName());
            Teacher clone = (Teacher) origin.deepClone();
            // 更改克隆后的d学生信息 更改了姓名
            clone.getStudent().setName("我是克隆对象更改后的学生2");
            System.out.println("克隆后的学生姓名：" + clone.getStudent().getName());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

当然这些工作都有现成的轮子了，借助于Apache Commons可以直接实现：

  • 浅克隆：BeanUtils.cloneBean(Object obj);
  • 深克隆：SerializationUtils.clone(T object);
Java中的深拷贝(深复制)和浅拷贝(浅复制) 示例代码
05-12
Java关于深拷贝(深复制)和浅拷贝(浅复制)比较通俗易懂的简单说明及示例代码...
深入JAVA对象深度克隆的详解
09-05
在Java中，深度克隆与浅克隆的区别在于处理对象内部引用的复杂性。浅克隆只复制对象本身，而不复制它所引用的对象，而深度克隆则会递归地复制对象及其引用的所有子对象。 当对象包含复杂的数据结构，如集合或嵌套的...
java 深克隆（深拷贝）与浅克隆（浅拷贝）详解
mindcarver
12-18 496
java深克隆和浅克隆 基本概念 浅复制(浅克隆) 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所拷贝的对象，而不复制它所引用的对象。 深复制(深克隆) 被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，...
Java 深克隆&浅克隆
u012780655的博客
10-19 230
Java 深克隆(DeepClone)与浅克隆(ShallowClone)是原型设计模式的灵魂。 记录结构： --什么是浅克隆？ --实现浅克隆 --什么是深克隆？ --实现深克隆 需求 Sunny 软件公司 OA 系统支持工作周报的快速克隆，极大提高了工作周报的编写效率，受到员工的一致好评。但有员工又发现一个问题，有些工作周报带有附件，例如经理助理“小...
JAVA深复制(深克隆)与浅复制(浅克隆)
weixin_34038293的博客
09-20 194
1．浅复制与深复制概念⑴浅复制（浅克隆）被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不 复制它所引用的对象。 ⑵深复制（深克隆）被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原 有的那些被引用的对象。换言之，深复制把要复...
也谈java浅克隆与深克隆
09-01 4088
如果我们有一个对象a，我们想得到它的一个克隆，那么我们该怎么做呢？最直观、最笨的方法是我们先new一个a的同类对象b，然后挨个拷贝a的属性给b中的相应属性。那么，这里马上就得引出两个概念：浅克隆与深克隆。 如果用直白的、非严格定义的语言来解释这两个概念，那么可以这么说： 所谓浅克隆是指复制一个对象的实例，但是这个对象中包含的其它的对象还是共用的。 所谓深克隆是指复制一个对象的实例，而且这个对
Java List的克隆与深拷贝：方法详解与陷阱揭秘
[Java List的克隆与深拷贝：方法详解与陷阱揭秘](https://geekole.com/wp-content/uploads/2022/11/apache_commons_java_geekole_1-1024x483.png) # 1. Java List概述与克隆概念 ## 1.1 Java List概述 Java List是...
Java对象深浅拷贝详解与实例
"这篇文档详细解释了Java中的对象拷贝，包括浅拷贝和深拷贝的概念，并通过实例展示了如何实现。" 在Java编程中，对象拷贝是一个关键概念，尤其是当你需要创建一个对象的独立副本，使得原对象和副本在后续修改时互不...
Java批处理与对象浅拷贝详解
在Java中，对象拷贝分为浅拷贝和深拷贝： **浅拷贝（浅复制/浅克隆）**： 在浅拷贝中，新创建的对象会拥有原始对象的属性值副本，但对引用类型变量的拷贝仅仅是复制了引用，而不是实际的对象。这意味着，如果原始...
Java之深复制浅复制
林林同學的博客
04-18 217
JAVA深复制(深克隆)与浅复制(浅克隆) 1．浅复制与深复制概念 ⑴浅复制（浅克隆） 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 ⑵深复制（深克隆） 被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再...
Java 深克隆 和 浅克隆
骑士梦的博客
07-05 373
浅克隆（Shadow Clone） 是把原型对象中成员变量为值类型的属性都复制给克隆对象，把原型对象中成员变量为引用类型的引用地址也复制给克隆对象，也就是原型对象中如果有成员变量为引用对象，则此引用对象的地址是共享给原型对象和克隆对象的。 简单来说就是浅克隆只会复制原型对象，但不会复制它所引用的对象，如下图所示： 深克隆（Deep Clone） 是将原型对象中的所有类型，无论是值类型还是引用类型，都复制一份给克隆对象，也就是说深克隆会把原型对象和原型对象所引用的对象，都复制一份给克隆对象，如下图
java 深度复制_JAVA深复制(深克隆)与浅复制(浅克隆)
weixin_39627455的博客
02-15 355
1．浅复制与深复制概念⑴浅复制(浅克隆)被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。⑵深复制(深克隆)被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的...
【Java基础】深克隆浅克隆
Johnny_sc的博客
12-08 304
浅谈Java中的深克隆和浅克隆、深克隆和浅克隆的区别和实现方式？ 克隆（复制）在Java中是一种常见的操作，目的是快速获取一个对象副本。克隆分为深克隆和浅克隆。 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。 总之，深浅克隆都会在堆中新分配一块区域，区别在于对象属性引用的对象是否需要进行克隆（递归性的）。 Show you my picture# pos:当前对
Java之深克隆与浅克隆
L__MY的博客
04-23 438
克隆类型 在Java语言中，数据类型分为值类型（基本数据类型）和引用类型，值类型包括int、double、byte、boolean、char等简单数据类型，引用类型包括类、接口、数组等复杂类型。浅克隆和深克隆的主要区别在于潜克隆复制的时候如果是值类型则直接克隆，而如果是引用类型则不会克隆对象引用的对象，而只是简单地复制这个引用。也就是说如果修改克隆后的对象中的引用类型数据，原对象中也会更改，因为都...
JAVA深克隆和浅克隆
sinat_35010165的博客
03-05 284
一、基础概念 1. 浅克隆（浅复制） 创建一个新对象，新对象的属性和原来的对象完全相同，对于非基本数据类型属性（即引用类型），扔指向原有属性所指向的对象的内存地址 2. 深克隆（深复制） 创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 二、JAVA的clone()方法 clone方法将对象复制了一份并返...
Java 深克隆和浅克隆
MustWinner的博客
08-08 650
Java 深克隆和浅克隆 一、为什么要克隆？ 使用场景: 当使用一个对象的属性时，需要进行一些修改，但是又不能直接修改该对象，此时我们就可以使用克隆来拷贝一个对象，进行操作。不然就需要new一个对象，对属性赋值。 总的来说为了保证引用类型的参数不被其他方法修改，可以使用克隆后的值作为参数传递。 一般情况下，我们实际需要使用的是深克隆。二、如何克隆三、代码** 浅克隆 运行结果 深克隆 结果 回顾一下浅克隆和深克隆的概念浅克隆是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象里面包含
【java】深克隆和浅克隆
XYZ
09-30 164
本文内容来自于：深浅克隆面试题汇总——附详细答案 1.使用克隆有什么好处？ 答：好处包含以下几点： 使用方便：假如要复制一个对象，但这个对象中的部分属性已经被修改过了，如果不使用克隆的话，需要给属性手动赋值，相比克隆而已麻烦很多； 性能高：查看 clone 方法可以知道，它是 native 方法，native 方法是原生函数，使用操作系统底层的语言实现的，因此执行效率更高； 隔离性：克隆...
Java中的深克隆与浅克隆
最新发布
qq_42798343的博客
08-27 2163
浅克隆：复制对象时不复制引用对象的内容，克隆对象和原对象共享引用对象。深克隆：复制对象时也复制引用对象的内容，克隆对象和原对象完全独立。实现深克隆的方式：重写clone()方法、使用序列化、使用第三方库（如Apache Commons Lang）、使用JSON序列化。了解深克隆和浅克隆的区别，并根据实际需要选择合适的克隆方式，可以帮助开发者更好地管理对象的复制和状态。希望这篇博客能够帮助你更好地理解Java中的深克隆和浅克隆！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值