基于java实现浅拷贝和深拷贝

最新推荐文章于 2025-06-04 09:30:22 发布
最新推荐文章于 2025-06-04 09:30:22 发布
阅读量3k 收藏 9
点赞数 1
CC 4.0 BY-SA版权
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41863849/article/details/125739614
本文详细介绍了Java中对象拷贝的概念，包括浅拷贝和深拷贝的区别，并通过实例展示了如何实现这两种拷贝。浅拷贝仅复制对象的基本数据类型，而深拷贝则会创建新的引用对象。文章提供了使用内置的Cloneable接口、序列化流以及开源工具如FastJson实现深拷贝的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

1、概念

浅拷贝：在拷贝一个对象时，复制基本数据类型的成员变量，但对引用数据类型的成员变量只进行引用的传递（复制其地址引用），并不会创建一个新的对象。简单地说就是被拷贝对象和浅拷贝得到的新对象，它们的引用数据类型的成员变量指向同一个内存地址。

深拷贝：在拷贝一个对象时，除了复制基本数据类型的成员变量，对引用数据类型的成员变量进行拷贝时，会创建一个新的对象来保存引用类型的成员变量。
简单地说就是被拷贝对象和深拷贝得到的新对象，它们的引用数据类型的成员变量指向不同的内存地址。

定义如下类：

class Person {
    private int age;
    
    private StringBuffer name;
}

对 Person 类的对象拷贝时，浅拷贝和深拷贝示意图区别如下：
在这里插入图片描述

2、浅拷贝

Java已经内置了 Cloneable 抽象原型接口，自定义的类型只需实现该接口并重写 Object.clone() 方法即可完成本类的浅拷贝。

Cloneable 是一个空接口。Java之所以提供 Cloneable 接口，只是为了在运行时通知Java虚拟机可以安全地在该类上使用 clone() 方法。而如果该类没有实现 Cloneable 接口，则调用 clone() 方法会抛出 CloneNotSupportedException 异常。

一般情况下，如果使用 clone() 方法，则需满足以下条件：
    1、对任何对象 o，都有 o.clone() != o。换言之，克隆对象与原型对象不是同一个对象；
    2、对任何对象 o，都有 o.clone().getClass() == o.getClass()。换言之，复制对象与原对象的类型一样；
    3、如果对象 o 的 equals() 方法定义恰当，则 o.clone().equals(o) 应当成立。

2.1、浅拷贝实战

假设，现在有两个类，学生 Student 和班级 Class，每个学生都有自己对应的班级：

/**
 * @Des 班级实体类
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Class {

    private int id;

    private String name;

    private String desc;
}


/**
 * @Des 学生实体类
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Cloneable{
    private int id;

    private String name;

    private int age;

    /**
     * 班级，一对一关系
     */
    private Class classs;

    /**
     * 重写 Object.clone()方法
     */
    @Override
    public Student clone() throws CloneNotSupportedException {
        /**
         * super.clone()方法直接从堆内存中以二进制流的方式进行复制，重新分配一个内存块，其效率很高；
         * 由于super.clone()方法基于内存复制，不会调用对象的构造函数，也就是不需要经历初始化过程；
         * 使用super.clone()方法，如果类中存在引用对象属性，则原型对象与克隆对象的该属性会指向同一对象的引用。
         */
        return (Student)super.clone();
    }
}

浅拷贝测试：

/**
 * @Des 浅拷贝测试
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
public class StudentTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Class classs = new Class(1, "一年级", "一年级的学生比较调皮");
        Student student = new Student(1, "基地", 7, classs);

        // 浅拷贝对象
        Student clone = student.clone();
        
        // 结果为 true，指向的是同一个内存地址
        System.out.println(student.getClasss() == clone.getClasss());
    }
}

3、深拷贝

深拷贝可以有以下几种不同的实现方式：
    1、嵌套 clone 方法：在需要克隆的对象以及该对象的引用类型的变量的类中全部实现 cloneable 接口，但是对于层级比较深的对象，不太友好；
    2、使用序列化流：使要序列化的对象和该对象的引用类型成员变量对象的类都实现 Serializable 接口，将对象序列化到输出流中，然后再反序列化为对象就完成了完全的复制操作。但是静态的成员和 transient 关键字修饰的成员不能被序列化；
    3、使用开源工具类，例如，json类库（FastJson，GSON等将对象转化为json字符串，然后将json字符串转换为对象），Spring的BeanUtils，Cglib的BeanCopier。

3.1、嵌套 clone 方法

定义实体类 Student 和 Class，两个实体类都实现 Cloneable 接口并重写 Object.clone()，对于引用数据类型的变量继续使用其重写的 clone 方法进行拷贝：

/**
 * @Des 班级实体类
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Class implements Cloneable{

    private int id;

    private String name;

    private String desc;

    /**
     * 重写 Object.clone()方法
     */
    @Override
    public Class clone() throws CloneNotSupportedException {
        return (Class)super.clone();
    }
}


/**
 * @Des 学生实体类
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Cloneable{
    private int id;

    private String name;

    private int age;

    /**
     * 班级，一对一关系
     */
    private Class classs;

    /**
     * 重写 Object.clone()方法
     */
    @Override
    public Student clone() throws CloneNotSupportedException {
        Student student = (Student)super.clone();
        /**
         * 对于引用数据类型，继续调用clone方法
         * 如果引用数据类型嵌套层级很多，每个层级都需要处理
         */
        student.classs = this.classs.clone();
        return student;
    }
}

测试：

/**
 * @Des 深拷贝测试（嵌套 clone）
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
public class StudentTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Class classs = new Class(1, "一年级","一年级的学生比较调皮");
        Student student = new Student(1, "基地",7, classs);

        // 深拷贝对象
        Student clone = student.clone();

        // 结果为false
        System.out.println(student.getClasss() == clone.getClasss());
    }
}

3.2、使用序列化流

定义序列化工具类 SerialCloneUtils ：

/**
 * @Des
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/12
 */
@Slf4j
public class SerialCloneUtils {

    /**
     * @Desc 使用ObjectStream序列化实现深克隆
     * @Author jidi
     * @date 2022/7/12 9:52
     */
    public static <T extends Serializable> T deepClone(T t) throws CloneNotSupportedException {
        ByteArrayOutputStream bout = null;
        ObjectOutputStream out = null;
        InputStream bin = null;
        ObjectInputStream in = null;
        try {
            // 保存对象为字节数组
            bout = new ByteArrayOutputStream();
            out = new ObjectOutputStream(bout);
            out.writeObject(t);

            // 从字节数组中读取克隆对象
            bin = new ByteArrayInputStream(bout.toByteArray());
            in = new ObjectInputStream(bin);
            return (T)(in.readObject());
        }catch (IOException | ClassNotFoundException e){
            CloneNotSupportedException cloneNotSupportedException = new CloneNotSupportedException();
            e.initCause(cloneNotSupportedException);
            throw cloneNotSupportedException;
        }finally {
            try {
                if (Objects.nonNull(bout)){
                    bout.close();
                }
                if (Objects.nonNull(out)){
                    out.close();
                }
                if (Objects.nonNull(bin)){
                    bin.close();
                }
                if (Objects.nonNull(in)){
                    in.close();
                }
            } catch (IOException e) {
                log.error("关闭IO流失败：{}", e);
            }
        }
    }
}

创建一个公共父类 SerialClone ，只要继承该类就可以实现深克隆：

/**
 * @Des
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/12
 */
public class SerialClone implements Cloneable, Serializable {
    private static final long serialVersionUID = -3556726131986995463L;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return SerialCloneUtils.deepClone(this);
    }

}

定义实体类 Student 和 Class，分别继承 SerialClone 类：

/**
 * @Des 班级实体类
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Class extends SerialClone{

    private int id;

    private String name;

    private String desc;
}


/**
 * @Des 学生实体类
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student extends SerialClone{
    private int id;

    private String name;

    private int age;

    /**
     * 班级，一对一关系
     */
    private Class classs;
}

测试：

/**
 * @Des 深复制测试
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
public class StudentTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Class classs = new Class(1, "一年级","一年级的学生比较调皮");
        Student student = new Student(1, "基地",7, classs);

        // 深拷贝对象
        Student clone = (Student)student.clone();

        // 结果为false
        System.out.println(student.getClasss() == clone.getClasss());
    }
}

3.3、使用开源工具类

此处使用 FastJson 实现深拷贝：

/**
 * @Des 班级实体类
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
@AllArgsConstructor
@NoArgsConstructor
@Data
public class Class{

    private int id;

    private String name;

    private String desc;
}

/**
 * @Des 学生实体类
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student{
    private int id;

    private String name;

    private int age;

    /**
     * 班级，一对一关系
     */
    private Class classs;
}


/**
 * @Des 深复制测试
 * @Author jidi
 * @Email jidi_jidi@163.com
 * @Date 2022/7/11
 */
public class StudentTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        Class classs = new Class(1, "一年级","一年级的学生比较调皮");
        Student student = new Student(1, "基地",7, classs);

        // 使用 FastJson 深拷贝对象
        Student clone = JSONObject.parseObject(JSONObject.toJSONBytes(student), Student.class);

        // 结果为false
        System.out.println(student.getClasss() == clone.getClasss());
    }
}

可以看到使用JSON类库进行深拷贝时，实体类不需要实现任何接口即可。但是需要注意的是，不同的JSON类库序列化规则不一样，对于某些表示是否的变量，命名时最好不要使用 isXxx 形式，否则会导致序列化失败。

创建型模式-原型(Prototype)-解决复制创建对象问题-浅拷贝深拷贝
BXA
04-08 1260
创建型模式-原型(Prototype)-解决复制创建对象问题-浅拷贝深拷贝
深入理解Java中的Clone与深拷贝和浅拷贝
学海一乌鸦的博客
05-15 2099
1.Java对象的创建 clone顾名思义就是复制， 在Java语言中， clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。 那么在java语言中，有几种方式可以创建对象呢？&nbsp; 使用new操作符创建一个对象。 使用clone方法复制一个对象。 使用new和clone的区别： new操作符的本意是分...
Java 浅拷贝和深拷贝的理解和实现方式
会写Bug的攻城狮
10-24 362
总结： 对象的拷贝，有浅拷贝和深拷贝之分，浅拷贝就是拷贝给另一个对象的是本对象存储的地址，而不是新开辟的存储区域去存放新的这个对象，这样不管是修改原对象还是新对象的内容，都会将原对象和新对象的内容修改掉。深拷贝就是新开辟一块存储区域去存储拷贝来的对象，这样修改原对象，也不会影响新对象的值。 浅拷贝的三种实现方式（除String类型外，他比较特殊，它是字符串常量，不能被修改，重新给他复制的话，他就会创建新的内存区域去存储新的值）： 直接将引用对象赋值给另一个对象 通过拷贝构造方法实现浅拷贝 通过
Java 深拷贝与浅拷贝：原理、实现与应用场景详解
最新发布
qq_20294455的博客
06-04 1450
Java对象拷贝可分为浅拷贝与深拷贝：浅拷贝仅复制对象本身及其基本属性，引用类型仍指向原对象；深拷贝则递归复制所有层级，创建完全独立的对象图。实现方式上，浅拷贝通过Cloneable接口实现，深拷贝可采用手动递归、序列化或第三方库（如Apache Commons）。关键区别在于引用类型属性是否独立，选择时应考虑对象复杂度与性能需求。最佳实践包括优先使用拷贝构造器替代Cloneable、集合对象需特别注意元素拷贝，以及合理权衡内存与性能。正确选择拷贝策略能有效避免对象共享带来的数据同步问题。
java使用fastjson深拷贝对象
LuoHuaX的博客
01-12 1062
java使用fastjson深拷贝对象
Java的浅拷贝和深拷贝实现
u012424449的博客
07-10 287
main方法 public static void main(String[] args) throws Exception { CopyTest copyTest = new CopyTest(); copyTest.setName("张三"); CopyTest.Address address = copyTest.new Address(); address.setCity("杭州"); address.setProvi
fastJson深拷贝
一个技术菜鸟的博客
03-29 1787
在调用toJsonString时一定要指定打印类型信息（SerializerFeature.WriteClassName），否者反序列化时因没有具体类型导致信息丢失！ 比如： import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.serializer.SerializerFeature; import lombok.Data; import org.junit.jupiter.api.Test; /** * @author zhou
Java当中的深拷贝和浅拷贝
qq_39939541的博客
07-23 1520
从输出结果可以看出，尽管我们使用BeanUtils进行了拷贝，但person1和person2的属性值仍然是相同的，修改其中一个对象的属性值会同时影响另一个对象的属性值。它会创建一个全新的对象，并将原始对象中的所有属性或元素都复制到新的对象中。因此，若我们修改复制对象中的属性或元素，原始对象中对应的属性或元素不会受到任何影响。浅拷贝是一种复制对象到另一个变量的操作，它仅复制对象的地址而非对象本身。因此，若我们修改复制对象中的属性或元素，原始对象中对应的属性或元素也会随之改变。
java浅拷贝和深拷贝的实现方式
02-19
对象的拷贝，在 Java 中分为浅拷贝与深拷贝。对于这两种类型的实现方式，存在多种不同的途径。 浅拷贝会拷贝给另一个对象的是本对象存储的地址，而不是新开辟的存储区域去存放新的这个对象[^1]。 ### 浅拷贝实现 ...
JAVA 深层拷贝 DeepCopy的使用详解
09-05
总之，Java中实现深拷贝通常需要根据具体需求和对象结构来选择合适的方法，无论是序列化还是JSON转换，都需要权衡性能、可维护性和兼容性等因素。在实际项目中，还可以考虑使用一些专门用于对象拷贝的库，如Apache ...
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
今天小编就为大家分享一篇关于Java Clone深拷贝与浅拷贝的两种实现方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
java怎么把浅拷贝变成深拷贝
04-01
### Java 深拷贝与浅拷贝的区别及其实现 #### 浅拷贝 在 Java 中，浅拷贝是指创建一个新的对象，并将原始对象中的字段复制到新对象中。对于基本数据类型的字段，会直接复制其值；而对于引用类型的字段，则只复制...
java深拷贝 VS 浅拷贝
03-30
### Java 深拷贝与浅拷贝的区别及实现方法 #### 浅拷贝 在 Java 中，浅拷贝指的是创建一个新的对象，并将原始对象的字段值复制到新对象中。如果字段是基本数据类型，则会直接复制其值；如果是引用类型的变量，则只...
Java 的深拷贝和浅拷贝
扛麻袋的少年的博客
04-20 973
1.创建对象的 5 种方式 通过 new 关键字        这是最常用的一种方式，通过 new 关键字调用类的有参或无参构造方法来创建对象。比如 Object obj = new Object(); 通过 Class 类的 newInstance() 方法      &nb...
Java代码实现—深拷贝与浅拷贝
weixin_44580000的博客
05-27 2608
1
JAVA学习-深拷贝和浅拷贝的实现方式
qq_48772498的博客
01-19 236
在 Java 的学习过程，很多人在拷贝的时候，都习惯用 clone 方法直接拷贝，但有时候总会出现一些问题，看我举例： 先定义Person类存储个人信息： class Person implements Cloneable{ //姓名 String name; //电话 String phone; //性别 String sex; public Person(String name, String phone, String sex) {
死磕Java面试系列：深拷贝与浅拷贝的实现原理
m0_73311735的博客
11-07 975
只拷贝栈内存中的数据，不拷贝堆内存中数据。既拷贝栈内存中的数据，又拷贝堆内存中的数据。
java深拷贝_java深拷贝的实现
weixin_39899630的博客
02-19 428
在有些业务场景下，我们需要两个完全相同却彼此无关的java对象。比如使用原型模式、多线程编程等。对此，java提供了深拷贝的概念。通过深度拷贝可以从源对象完美复制出一个相同却与源对象彼此独立的目标对象。这里的相同是指两个对象的状态和动作相同，彼此独立是指改变其中一个对象的状态不会影响到另外一个对象。实现深拷贝常用的实现方式有2种：Serializable,Cloneable。Serializabl...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值