Java中的深拷贝与浅拷贝

最新推荐文章于 2025-05-30 20:50:41 发布
原创 最新推荐文章于 2025-05-30 20:50:41 发布 · 1k 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

什么是拷贝

在Java中，拷贝是指创建一个对象的副本。拷贝主要分为两种类型：浅拷贝(Shallow Copy)和深拷贝(Deep Copy)。理解这两种拷贝的区别对于编写正确的Java程序非常重要，特别是在处理对象引用时。

浅拷贝(Shallow Copy)

浅拷贝是指创建一个新对象，然后将原始对象的所有字段值复制到新对象中。如果字段是基本类型，则直接复制其值；如果字段是引用类型，则复制引用但不复制引用的对象。因此，原始对象和副本对象将共享引用类型的字段。

浅拷贝的实现方式

在Java中，实现浅拷贝有几种方式：

  1. 使用clone()方法：Object类提供了clone()方法，可以实现浅拷贝

  2. 使用构造方法：通过构造方法复制每个字段

  3. 使用拷贝工厂方法

class Department implements Cloneable {
    private String name;
    
    public Department(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Employee implements Cloneable {
    private String name;
    private Department department;
    
    public Employee(String name, Department department) {
        this.name = name;
        this.department = department;
    }
    
    public String getName() {
        return name;
    }
    
    public Department getDepartment() {
        return department;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setDepartment(Department department) {
        this.department = department;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class ShallowCopyExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Department department = new Department("IT");
        Employee original = new Employee("John", department);
        Employee cloned = (Employee) original.clone();
        
        System.out.println("Original: " + original.getName() + " - " + original.getDepartment().getName());
        System.out.println("Cloned: " + cloned.getName() + " - " + cloned.getDepartment().getName());
        
        // 修改克隆对象的department
        cloned.getDepartment().setName("HR");
        
        System.out.println("\nAfter modifying cloned object:");
        System.out.println("Original: " + original.getName() + " - " + original.getDepartment().getName());
        System.out.println("Cloned: " + cloned.getName() + " - " + cloned.getDepartment().getName());
    }
}

 输出结果：

Original: John - IT
Cloned: John - IT

After modifying cloned object:
Original: John - HR
Cloned: John - HR

可以看到，修改克隆对象的department后，原始对象的department也被修改了，这是因为它们引用的是同一个Department对象。

深拷贝(Deep Copy)

深拷贝是指创建一个新对象，然后递归地复制原始对象的所有字段。对于引用类型的字段，不仅复制引用，还会创建引用对象的新副本。因此，原始对象和副本对象完全独立，互不影响。

深拷贝的实现方式

实现深拷贝有几种常见方法：

  1. 重写clone()方法：在clone()方法中手动复制所有引用类型的字段

  2. 使用序列化：将对象序列化为字节流，然后再反序列化为新对象

  3. 使用拷贝构造方法：创建接受原对象并复制所有字段的构造方法

  4. 使用第三方库：如Apache Commons Lang的SerializationUtils

方法1：重写clone()方法
class Department implements Cloneable {
    private String name;
    
    public Department(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Employee implements Cloneable {
    private String name;
    private Department department;
    
    public Employee(String name, Department department) {
        this.name = name;
        this.department = department;
    }
    
    public String getName() {
        return name;
    }
    
    public Department getDepartment() {
        return department;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setDepartment(Department department) {
        this.department = department;
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Employee cloned = (Employee) super.clone();
        cloned.department = (Department) department.clone(); // 深度拷贝department
        return cloned;
    }
}

public class DeepCopyExample1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Department department = new Department("IT");
        Employee original = new Employee("John", department);
        Employee cloned = (Employee) original.clone();
        
        System.out.println("Original: " + original.getName() + " - " + original.getDepartment().getName());
        System.out.println("Cloned: " + cloned.getName() + " - " + cloned.getDepartment().getName());
        
        // 修改克隆对象的department
        cloned.getDepartment().setName("HR");
        
        System.out.println("\nAfter modifying cloned object:");
        System.out.println("Original: " + original.getName() + " - " + original.getDepartment().getName());
        System.out.println("Cloned: " + cloned.getName() + " - " + cloned.getDepartment().getName());
    }
}

 输出结果：

Original: John - IT
Cloned: John - IT

After modifying cloned object:
Original: John - IT
Cloned: John - HR

 方法2：使用序列化实现深拷贝

import java.io.*;

class Department implements Serializable {
    private String name;
    
    public Department(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

class Employee implements Serializable {
    private String name;
    private Department department;
    
    public Employee(String name, Department department) {
        this.name = name;
        this.department = department;
    }
    
    public String getName() {
        return name;
    }
    
    public Department getDepartment() {
        return department;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setDepartment(Department department) {
        this.department = department;
    }
    
    public Employee deepCopy() throws IOException, ClassNotFoundException {
        // 将对象写入字节数组
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        oos.flush();
        
        // 从字节数组读取对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Employee) ois.readObject();
    }
}

public class DeepCopyExample2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Department department = new Department("IT");
        Employee original = new Employee("John", department);
        Employee cloned = original.deepCopy();
        
        System.out.println("Original: " + original.getName() + " - " + original.getDepartment().getName());
        System.out.println("Cloned: " + cloned.getName() + " - " + cloned.getDepartment().getName());
        
        // 修改克隆对象的department
        cloned.getDepartment().setName("HR");
        
        System.out.println("\nAfter modifying cloned object:");
        System.out.println("Original: " + original.getName() + " - " + original.getDepartment().getName());
        System.out.println("Cloned: " + cloned.getName() + " - " + cloned.getDepartment().getName());
    }
}

 输出结果与上一个相同：

Original: John - IT
Cloned: John - IT

After modifying cloned object:
Original: John - IT
Cloned: John - HR

浅拷贝与深拷贝的比较

特性浅拷贝深拷贝
基本类型字段复制值复制值
引用类型字段复制引用（共享对象）递归复制对象（不共享对象）
实现复杂度简单（通常只需调用super.clone）复杂（需要处理所有引用类型字段）
性能较高（复制较少）较低（需要复制更多对象）
对象独立性低（引用类型字段会相互影响）高（完全独立）

如何选择拷贝方式

选择浅拷贝还是深拷贝取决于具体需求：

  1. 使用浅拷贝的情况：

    • 对象的所有字段都是基本类型

    • 引用类型字段是不可变的（如String）

    • 你确实需要共享某些对象的状态

  2. 使用深拷贝的情况：

    • 对象包含可变引用类型字段

    • 你需要完全独立的副本

    • 副本的修改不应影响原始对象

注意事项

  1. clone()方法的限制：

    • 需要实现Cloneable接口，否则会抛出CloneNotSupportedException

    • clone()方法是protected的，如果要在其他包中调用，需要重写为public

    • 深拷贝实现需要确保所有相关类都正确实现了clone()

  2. 序列化的限制：

    • 所有相关类都必须实现Serializable接口

    • 序列化性能较低，不适合频繁拷贝的场景

    • 某些特殊对象（如线程）无法通过序列化正确拷贝

  3. 循环引用问题：

    • 在深拷贝时，如果对象图中有循环引用，需要特别处理，否则可能导致栈溢出

最佳实践

1.考虑使用拷贝构造方法或拷贝工厂方法替代clone()：

public Employee(Employee other) {
    this.name = other.name;
    this.department = new Department(other.department);
}

2.对于复杂的对象图，考虑使用第三方库如Apache Commons Lang的SerializationUtils.clone()：

Employee cloned = SerializationUtils.clone(original);

3.明确文档化你的拷贝行为，让使用者知道是浅拷贝还是深拷贝。

Java之deep copy(深复制)
hzycaicai2012的博客
05-07 2万+
前段时间碰到需要将一个Java对象进行深度拷贝的情况，但是JDK并未提供关于deep copy相关的API，唯一能用的就是一个不太稳定的clone()，所以问题就来了，如何实现稳定的deep copy，下面就实现deep copy的方法做个介绍。 1. 直接赋值 实现deep copy，首先想到的是可以直接赋值么？如下： Test test = new Test(); T
java，深拷贝和浅拷贝
水w的博客
09-16 1317
深拷贝和浅拷贝
Java中的深拷贝(深复制)和浅拷贝(浅复制)
weixin_34249678的博客
12-14 467
深拷贝(深复制)和浅拷贝(浅复制)是两个比较通用的概念，尤其在C++语言中，若不弄懂，则会在delete的时候出问题，但是我们在这幸好用的是Java。虽然java自动管理对象的回收，但对于深拷贝(深复制)和浅拷贝(浅复制)，我们还是要给予足够的重视，因为有时这两个概念往往会给我们带来不小的困惑。 浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。深拷...
【Java第68集】java对象深拷贝与浅拷贝详解
最新发布
一步一个脚印，冲冲冲。
05-30 1298
浅拷贝：仅复制引用字段地址，适合简单对象或共享引用场景。深拷贝：递归复制所有引用对象，适合复杂对象或需完全独立副本的场景。实现方式：可通过clone()、序列化或手动递归复制实现深拷贝。最佳实践：根据需求选择合适方法，权衡性能与安全性，避免常见错误。
浅谈Java中实现深拷贝的两种方式—clone() & Serialized
08-26
主要介绍了Java中实现深拷贝的两种方式—clone() & Serialized，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java的深拷贝和浅拷贝
09-19 281
熟悉C++的朋友对这个话题应该很熟悉，浅拷贝就是指两个对象共同拥有同一个值，一个对象改变了该值，也会影响到另一个对象。深拷贝就是两个对象的值相等，但是互相独立。本来想把以前写的一篇文章扩充一下，没想到居然牵扯出很多复杂的问题。本文测试环境是windows xp sp3中文版、NetBeans6.7.1,JDK1.6-update16。这里抛砖引玉，希望大家能提宝贵意见。 ...
Java深拷贝和浅拷贝（简单易懂）
shajjs的博客
07-14 4615
也就是说，浅拷贝只是复制了对象的“顶层”，对于引用类型的成员，实际上复制的是引用，而不是引用所指向的对象。深拷贝（Deep Copy）：创建一个新对象，不仅复制基本数据类型成员的值，对于引用数据类型的成员，也会为其创建新的对象，并复制其内容，使得新对象和原始对象完全独立，修改其中一个对象的引用类型成员不会影响到另一个对象。3.遵循 Java 的异常处理原则：对于可能出现异常的操作，按照良好的编程实践，应当声明可能抛出的异常，以便调用者能够进行适当的异常处理，增强程序的健壮性和可靠性。
最简单的深拷贝_飘云羽逸_新浪博客
飘云羽逸
10-16 334
package com.leitan.architect.pattern.prototype.deep;import java.io.*;import java.util.Date;public class QiTianDaSheng extends Monkey implements Cloneable, Serializable { public JinGuBang ji...
Java中的深拷贝
热门推荐
姑娘眼中的明月色，就只有你一人，轻轻望去，才能发现。
03-20 1万+
简单的说，深拷贝对引用数据类型的成员变量的对象图中所有的对象都开辟了内存空间；而浅拷贝只是传递地址指向，新的对象并没有对引用数据类型创建内存空间。
Java Clone深拷贝与浅拷贝的两种实现方法
08-26
Java Clone 是 Java 语言中的一种复制对象的机制，它可以将一个对象的所有属性和状态复制到另一个对象中，实现对象的深拷贝和浅拷贝。下面我们将讨论 Java 中的深拷贝和浅拷贝的两种实现方法。 一、浅拷贝 浅拷贝...
Java中的深拷贝(深复制)和浅拷贝(浅复制)介绍
09-03
在Java编程语言中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种不同的对象复制方式，它们涉及到内存中数据的复制和引用的处理。理解这两种拷贝方式对于开发过程中正确管理和操作对象至关重要。 浅拷贝，又...
java深入理解浅拷贝和深拷贝
12-21
在Java编程中，深入理解浅拷贝和深拷贝是非常重要的概念，特别是在处理对象复制时。浅拷贝和深拷贝的区别在于复制对象时对内存中数据的处理方式。 浅拷贝（Shallow Copy）指的是创建一个新的对象，该对象与原对象...
小问题6 | Java中如何实现深拷贝？实现深拷贝的三种方法
dongangsta的博客
03-05 4157
小问题6 | Java中如何实现深拷贝？实现深拷贝的三种方法
Java 对象进行深拷贝
TMesh的博客
01-28 1764
说了这么多深拷贝的实现方法，哪一种方法才是最好的呢？最简单的判断就是根据拷贝的类（包括其成员变量）是否提供了深拷贝的构造函数、是否实现了Cloneable接口、是否实现了Serializable接口、是否实现了默认的无参构造函数来进行选择。深拷贝方法优点缺点构造函数1.底层实现简单2.不需要引入第三方包3.系统开销小4.对拷贝类没有要求，不需要实现额外接口和方法1.可用性差，每次新增成员变量都需要新增新的拷贝构造函数重载clone()方法1.底层实现较简单2.不需要引入第三方包。
java中关于深拷贝的几种方式
wsb8233696的博客
05-28 7242
Object父类有个clone()的拷贝方法，不过它是protected类型的 ，我们需要重写它并修改为public类型，除此之外，子类还需要实现Cloneable接口来告诉JVM这个类上是可以拷贝的。Java提供了序列化的能力，我们可以先将源对象进行序列化，再反序列化生成拷贝对象。需要注意的是，super.clone()其实是浅拷贝，所以在重写User类的clone()方法时，address对象需要调用address.clone()重新赋值。
Java 深拷贝和浅拷贝
weixin_34087503的博客
03-08 125
2019独角兽企业重金招聘Python工程师标准>>> ...
Java中的深拷贝和浅拷贝
liuergo的博客
10-20 1043
在之前做项目的时候，同组的人因为深拷贝和浅拷贝的问题产生过BUG，当时不是自己负责的部分，没对这个问题做过深入的了解，今天深入学习一下???? 在介绍深拷贝和浅拷贝之前，先温习几个概念。 数据类型 Java中的数据类型有两种： 基本类型：粒度最小的数据类型。主要包括 4种整数类型：int、short、long、byte 2种浮点数类型：float、double 1种字符类型：char 1种布尔...
Java深拷贝
不夜城的油条的博客
11-27 286
public class DeepCopy { public static Object copy(Object orig) throws NotSerializableException { Object obj = null; try { // Write the object out to a byte array ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值