Java对象的浅拷贝和深拷贝

最新推荐文章于 2024-07-14 21:34:05 发布
原创 最新推荐文章于 2024-07-14 21:34:05 发布 · 592 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

一、什么是浅拷贝和深拷贝

Java中的对象拷贝(Object Copy)：指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去，主要分为浅拷贝(Shallow Copy)、深拷贝(Deep Copy)。

浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。简而言之，浅拷贝只是传递地址指向，新的对象并没有对引用数据类型创建内存空间。

深拷贝：深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。简而言之，深拷贝对引用数据类型的成员变量的对象图中所有的对象都开辟了内存空间。

二、分别在什么场景下使用浅拷贝和深拷贝

在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用现有对象的部分或全部数据。深拷贝相比于浅拷贝速度较慢并且花销较大。

对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。简而言之，需要复用现有对象的基本类型的成员变量数据时，浅拷贝即可。

对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。简而言之，需要复用现有对象的引用类型的成员变量数据时，需要使用深拷贝。

 

三、实现浅拷贝和深拷贝的方法

浅拷贝的实现方式：

1、通过拷贝构造方法实现浅拷贝：

拷贝构造方法指的是该类的构造方法参数为该类的对象。使用拷贝构造方法可以很好地完成浅拷贝，直接通过一个现有的对象创建出与该对象属性相同的新的对象。

2、通过重写clone()方法进行浅拷贝：

Object类是类结构的根类，其中有一个方法为protected Object clone() throws CloneNotSupportedException，这个方法就是进行的浅拷贝。有了这个浅拷贝模板，我们可以通过调用clone()方法来实现对象的浅拷贝。但是需要注意：1、Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法。

参考代码如下：对Student类的对象进行拷贝，直接重写clone()方法，通过调用clone方法即可完成浅拷贝。

package com.stqin.study.java;

/**
 * clone方法实现浅拷贝
 */
public class ShallowCopy {
    public static void main(String[] args) {
        Age a = new Age(20);
        Student stu1 = new Student("Bob", a, 175);

        // 通过调用重写后的clone方法进行浅拷贝
        Student stu2 = (Student) stu1.clone();
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());

        // 尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("Tim");
        // 改变age这个引用类型的成员变量的值
        a.setAge(99);
        // 使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
        // stu1.setaAge(new Age(99));
        stu1.setLength(216);
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

/**
 * 创建年龄类
 */
class Age {
    private int age;

    public Age(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return this.age + "";
    }
}

/**
 * 创建学生类
 */
class Student implements Cloneable {
    // 学生类的成员变量（属性）,其中一个属性为类的对象
    private String name;
    private Age aage;
    private int length;

    // 构造方法,其中一个参数为另一个类的对象
    public Student(String name, Age a, int length) {
        this.name = name;
        this.aage = a;
        this.length = length;
    }

    public String getName() {
        return name;
    }

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

    public Age getaAge() {
        return this.aage;
    }

    public void setaAge(Age age) {
        this.aage = age;
    }

    public int getLength() {
        return this.length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    // 设置输出的字符串形式
    @Override
    public String toString() {
        return "姓名是： " + this.getName() + "， 年龄为： " + this.getaAge().toString() + ", 长度是： " + this.getLength();
    }

    // 重写Object类的clone方法
    @Override
    public Object clone() {
        Object obj = null;
        // 调用Object类的clone方法，返回一个Object实例
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

 

深拷贝的实现方式：

1、通过重写clone方法来实现深拷贝

与通过重写clone方法实现浅拷贝的基本思路一样，只需要为对象图的每一层的每一个对象都实现Cloneable接口并重写clone方法，最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝。简单的说就是：每一层的每个对象都进行浅拷贝=深拷贝。

参考代码如下：

package com.stqin.study.java;

/**
 * 层次调用clone方法实现深拷贝
 */
public class DeepCopy {
    public static void main(String[] args) {
        Age a = new Age(20);
        Student stu1 = new Student("Bob", a, 175);

        // 通过调用重写后的clone方法进行浅拷贝
        Student stu2 = (Student) stu1.clone();
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());

        // 尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("Tim");
        // 改变age这个引用类型的成员变量的值
        a.setAge(99);
        // 使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
        // stu1.setaAge(new Age(99));
        stu1.setLength(216);
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

/**
 * 创建年龄类
 */
class Age implements Cloneable {
    private int age;

    public Age(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return this.age + "";
    }

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

/**
 * 创建学生类
 */
class Student implements Cloneable {
    // 学生类的成员变量（属性）,其中一个属性为类的对象
    private String name;
    private Age aage;
    private int length;

    // 构造方法,其中一个参数为另一个类的对象
    public Student(String name, Age a, int length) {
        this.name = name;
        this.aage = a;
        this.length = length;
    }

    public String getName() {
        return name;
    }

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

    public Age getaAge() {
        return this.aage;
    }

    public void setaAge(Age age) {
        this.aage = age;
    }

    public int getLength() {
        return this.length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    @Override
    public String toString() {
        return "姓名是： " + this.getName() + "， 年龄为： " + this.getaAge().toString() + ", 长度是： " + this.getLength();
    }

    // 重写Object类的clone方法
    @Override
    public Object clone() {
        Object obj = null;
        // 调用Object类的clone方法——浅拷贝
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        // 调用Age类的clone方法进行深拷贝
        // 先将obj转化为学生类实例
        Student stu = (Student) obj;
        // 学生类实例的Age对象属性，调用其clone方法进行拷贝
        stu.aage = (Age) stu.getaAge().clone();
        return obj;
    }
}

2、通过对象序列化实现深拷贝

虽然层次调用clone方法可以实现深拷贝，但是显然代码量实在太大。特别对于属性数量比较多、层次比较深的类而言，每个类都要重写clone方法太过繁琐。

将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。

参考代码如下：

package com.stqin.study.java;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 通过序列化实现深拷贝
 */
public class DeepCopyBySerialization {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Age a = new Age(20);
        Student stu1 = new Student("Bob", a, 175);
        // 通过序列化方法实现深拷贝
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(stu1);
        oos.flush();
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        Student stu2 = (Student) ois.readObject();
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
        // 尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("Tim");
        // 改变age这个引用类型的成员变量的值
        a.setAge(99);
        stu1.setLength(216);
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}

/**
 * 创建年龄类
 */
class Age implements Serializable {
    private int age;

    public Age(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return this.age + "";
    }
}

/**
 * 创建学生类
 */
class Student implements Serializable {
    // 学生类的成员变量（属性）,其中一个属性为类的对象
    private String name;
    private Age aage;
    private int length;

    // 构造方法,其中一个参数为另一个类的对象
    public Student(String name, Age a, int length) {
        this.name = name;
        this.aage = a;
        this.length = length;
    }

    public String getName() {
        return name;
    }

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

    public Age getaAge() {
        return this.aage;
    }

    public void setaAge(Age age) {
        this.aage = age;
    }

    public int getLength() {
        return this.length;
    }

    public void setLength(int length) {
        this.length = length;
    }

    // 设置输出的字符串形式
    @Override
    public String toString() {
        return "姓名是： " + this.getName() + "， 年龄为： " + this.getaAge().toString() + ", 长度是： " + this.getLength();
    }
}

 

 

JAVA复制一个对象：浅拷贝与深拷贝详解
02-05 782
JAVA复制一个对象：浅拷贝与深拷贝详解
java，深拷贝和浅拷贝
水w的博客
09-16 1480
深拷贝和浅拷贝
Java对象的深复制和浅复制
weixin_34357962的博客
03-31 312
2019独角兽企业重金招聘Python工程师标准>>> ...
Java中的深拷贝和浅拷贝介绍
北风
08-19 551
对象拷贝(Object Copy)就是将一个对象的属性拷贝到另一个有着相同类类型的对象中去。在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用对象的部分或全部 数据。Java中有三种类型的对象拷贝：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)、延迟拷贝(Lazy Copy) 一、引言    对象拷贝(Object Copy)就是将一个对象的属性拷贝到另一个有着
Java 浅拷贝和深拷贝的理解和实现方式
weixin_30662011的博客
10-11 722
Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。举例说明：比如，对象A和对象B都属于类S，具有属性a和b。那么对对象A进行拷贝操作赋值给对象B就是：B.a=A.a; B.b=A.b; 在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用现有对象的部分或全部 数据。 Java中的对象拷贝主要分为：浅拷贝(Shal...
java基础对象浅复制和深复制(基础知识)
赵英超的博客
10-30 804
1、创建对象的5种方式 　　①、通过 new 关键字 　　这是最常用的一种方式，通过 new 关键字调用类的有参或无参构造方法来创建对象。比如 Object obj = new Object(); 　　②、通过 Class 类的 newInstance() 方法 　　这种默认是调用类的无参构造方法创建对象。比如Person p2 = (Person) Class.forName("com...
java深入理解浅拷贝和深拷贝
12-21
在Java编程中，深入理解浅拷贝和深拷贝是非常重要的概念，特别是在处理对象复制时。浅拷贝和深拷贝的区别在于复制对象时对内存中数据的处理方式。 浅拷贝（Shallow Copy）指的是创建一个新的对象，该对象与原对象...
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅拷贝的两种实现方法。 一、浅拷贝 浅拷贝...
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
总的来说，Java中的深拷贝和浅拷贝是处理对象复制时的关键概念。正确理解和使用它们可以避免不必要的错误，特别是在处理复杂的对象结构时。在编写代码时，一定要根据实际情况来决定使用哪种拷贝方式，以满足程序的...
Java中的浅拷贝和深拷贝有什么区别？
破损的天堂鸟博客
06-23 1523
在Java中，浅拷贝和深拷贝是两种不同的对象拷贝方式，它们的主要区别在于是否复制对象的引用类型以及如何处理这些引用类型。总结来说，浅拷贝只是复制了对象的引用地址，而深拷贝则是复制了对象本身及其引用的对象，确保新对象与原对象完全独立。
Java对象深拷贝和浅拷贝
苏雨丶
06-03 364
前言 拷贝功能，在电脑上我们经常用到，也许换个名字更容易理解，那就是复制功能。我们平常复制以后就是两个独立的文件，修改其中一个文件的内容并不会影响另一个文件的内容。我们平常在写代码的时候，也经常会有这样的场景，把一个对象完完全全的复制一份出来，那么我们Java里面的对象拷贝是啥样的呢？ 拷贝方式 浅拷贝 我们先不说什么事浅拷贝，我们先举个栗子???? 1： 同类型对象直接将值赋给另一个对象 Son son = new Son() .setName("小明");
Java对象浅拷贝和深拷贝
蜗牛学习笔记
01-28 824
浅拷贝说明 对于数据类型是基本数据类型的成员变量，浅拷贝时候会直接复制一份属性值给到新对象。 对于数据类型是引用数据类型的成员变量，比如说成员变量是集合列表、某个类的对象，那么浅拷贝会进行引用传递，就是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。 深拷贝说明 浅拷贝时候，对于基本数据类型都已经实现拷贝后修改无影响了，对引用类型的拷贝因为指向同一内存空间而没有实现彻底的隔离。若要实现深拷贝，
java浅拷贝与深拷贝
che_lys的博客
02-25 1621
假如是简单的对象复用，其实也称之为拷贝，例如，新建一个对象A，然后令B = A，此时即拷贝了A。teacher1和teacher2通过引用关系（内存中的栈区），实际上，最终都指向了一个对象（内存中的堆区），只是引用名称不同，这种称之为引用拷贝。浅拷贝与深拷贝，都属于对象拷贝。处于对象拷贝类型下。主要区别在于，假如产生对象引用其他对象时，这个第三方被引用的对象是否因为拷贝产生变化！· 对象拷贝中，浅拷贝对象，指向第三方对象时，第三方对象不变。反之，深拷贝的简单理解，会导致指向的对象，实际也是不同。
Java 对象的浅拷贝和深拷贝
JUN_LLLL的博客
03-02 305
https://my.oschina.net/jackieyeah/blog/206391 https://blog.youkuaiyun.com/u014727260/article/details/55003402 https://segmentfault.com/a/1190000010648514
java对象的浅拷贝和深拷贝
程序员Monkey的专栏
12-03 2500
我们知道，每个对象都有拷贝其对象的能力，是因为每个对象都是一个Object子类，而Object提供clone方法，一个类实现了Cloneable接口就表示该类具备了被拷贝的能力,如果再覆写里面的clone方法就会完全具备拷贝的能力，拷贝是在内存中进行的，所以在性能方面比直接通过new生成对象要快很多，特别是在大对象的生成上，这会使性能的提升非常显著，Object提供的clone方法只是一种浅拷贝方
Java对象的浅拷贝与深拷贝
Dave's Blog
08-02 1214
浅拷贝与深拷贝 浅拷贝（浅克隆）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对拷贝对象的引用仍然指向原来的对象。换言之，浅拷贝仅仅复制基本数据类型，而不复制引用类型的对象。 深拷贝（深克隆）：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深拷贝把要复制的
Java中对象的浅拷贝与深拷贝
u014732103的博客
02-22 257
先了解一下什么是浅拷贝和深拷贝，简单来说： 1、浅拷贝，就是增加一个引用，实际还是指向原来的数据内存区。 2、深拷贝，不仅新增一个引用，并且会申请一块内存，引用指向新的内存区。或者这样理解 1、浅拷贝：浅拷贝只是单纯的对于对象的拷贝，对象属性对于其它对象的引用并没有进行拷贝（也就是说浅拷贝创建的对象和原来对象指向不同的地址空间，但是对象属性里面对其它对象的引用【引用属性】指向的还是同一
Java深拷贝和浅拷贝（简单易懂）
shajjs的博客
07-14 4911
也就是说，浅拷贝只是复制了对象的“顶层”，对于引用类型的成员，实际上复制的是引用，而不是引用所指向的对象。深拷贝（Deep Copy）：创建一个新对象，不仅复制基本数据类型成员的值，对于引用数据类型的成员，也会为其创建新的对象，并复制其内容，使得新对象和原始对象完全独立，修改其中一个对象的引用类型成员不会影响到另一个对象。3.遵循 Java 的异常处理原则：对于可能出现异常的操作，按照良好的编程实践，应当声明可能抛出的异常，以便调用者能够进行适当的异常处理，增强程序的健壮性和可靠性。
超详细！Java浅拷贝与深拷贝
2302_81982408的博客
05-25 1225
超详细！浅克隆与深克隆的实现与运用
Java中浅拷贝和深拷贝
最新发布
05-27
### Java中浅拷贝与深拷贝的区别及实现方式 #### 1. **基本概念** 在Java编程中，对象的拷贝分为两种主要形式：浅拷贝和深拷贝。这两种拷贝方式的核心差异在于它们对待对象内部引用字段的不同处理策略[^1]。 - 浅拷贝是指创建一个新的对象，并将原对象中的所有字段按位复制到新对象中。如果字段是基础数据类型，则直接复制其值；如果是引用类型，则只复制引用地址而不克隆实际的对象实例[^5]。 - 深拷贝不仅会复制对象本身，还会递归地复制该对象所包含的所有子对象，从而确保源对象及其所有嵌套对象与目标对象完全独立[^3]。 --- #### 2. **实现方式** ##### （1）**浅拷贝** 在Java中，默认情况下通过继承`Object`类并覆盖其受保护的方法`clone()`即可实现浅拷贝。具体步骤如下： - 被复制的类需实现`Cloneable`接口以表明支持克隆操作； - 重写`clone()`方法，在其中调用`super.clone()`完成初步的字段复制过程[^2]。 下面给出一个简单的示例代码片段用于演示如何执行浅拷贝： ```java class Person implements Cloneable { private String name; private Address address; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } // Getter and Setter methods omitted for brevity. } ``` 在这个例子当中，当我们尝试克隆一个Person实例时，虽然name属性会被正常复制成新的String对象，但由于address是一个复合型成员变量（即另一个类Address的实例），所以实际上只是简单地把原有的reference赋给了新产生的person object而已[^4]。 --- ##### （2）**深拷贝** 为了达到真正的深拷贝效果，除了遵循上面提到的步骤外，还需要额外采取措施去分别处理那些非基本类型的成员变量。通常有两种通用做法可供选择： - **手动逐个克隆**: 在自定义的`clone()`方法里面针对每一个非基本类型的field单独调用相应的克隆逻辑。 ```java @Override protected Object clone() throws CloneNotSupportedException { Person clonedPerson = (Person) super.clone(); clonedPerson.address = (Address) this.address.clone(); // Assuming Address also overrides clone(). return clonedPerson; } ``` 这里假设Address也已经适当地覆写了自身的`clone()`函数[^3]。 - **序列化反序列化技术**: 利用Java内置的对象流机制自动完成深层次的数据分离工作。这种方法无需显式修改原有业务模型就能轻松获得完整的副本，但前提是参与序列化的各个组件都必须标记为Serializable才行。 ```java public static <T extends Serializable> T deepCopy(T obj) throws Exception { ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(bos); out.writeObject(obj); ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream in = new ObjectInputStream(bis); return (T)in.readObject(); } ``` 上述辅助工具接受任意可串行化的输入参数obj并通过中间媒介暂存后再还原出来形成最终的结果[^3]。 --- ### 总结表格对比 | 特性 | 浅拷贝 | 深拷贝 | |--------------------|---------------------------------------------|----------------------------------------------| | 定义 | 创建新对象并将原始对象的部分内容复制过去 | 将整个对象树全部重新构建一遍 | | 引用关系 | 子对象仍共享同一份实体 | 各级节点均拥有各自独立的存在 | | 实现难度 | 较易 | 更加复杂 | | 效率 | 高 | 相对较低 | ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值