当前位置：首页 > 文章列表 > 文章 > java教程 > Java深浅拷贝详解与实用技巧教程

Java深浅拷贝详解与实用技巧教程

2025-08-08 11:15:49 0浏览收藏

golang学习网今天将给大家带来《Java深浅拷贝详解与实用拷贝技巧教程》，感兴趣的朋友请继续看下去吧！以下内容将会涉及到等等知识点，如果你是正在学习文章或者已经是大佬级别了，都非常欢迎也希望大家都能给我建议评论哈~希望能帮助到大家！

深拷贝会完全复制对象及其所有嵌套对象，确保新旧对象内存独立，而浅拷贝仅复制对象本身和基本类型字段，引用类型字段共享同一地址。1. 浅拷贝可通过实现Cloneable接口并重写clone()方法或使用拷贝构造函数实现，但对引用字段仅复制引用地址；2. 深拷贝需递归调用clone()或拷贝构造函数，对每个引用字段也创建新实例；3. 序列化方式可自动实现深拷贝，要求所有对象实现Serializable接口，能处理复杂对象图和循环引用，但性能开销大；4. 实际选择时，若对象不可变则无需拷贝，结构简单时用拷贝构造函数，复杂结构优先考虑序列化，避免使用Object.clone()因其实现繁琐且易出错；5. 区分深浅拷贝的关键在于防止意外的数据共享，尤其在多线程或需独立快照的场景中深拷贝更安全。

java怎样实现对象的深拷贝与浅拷贝 java对象拷贝的实用操作技巧教程

在Java的世界里，对象拷贝是个绕不开的话题，它不像基本数据类型那样直接，一个不小心就可能埋下隐蔽的bug。简单来说，它关乎你复制一个对象时，是只复制它的“外壳”（引用），还是把“内里”（所有数据，包括嵌套对象）也完完整整地复制一份。浅拷贝只是复制了对象本身以及它所包含的基本类型字段，对于引用类型字段，它复制的是引用地址，这意味着新旧对象会共享同一个引用指向的内存区域。而深拷贝则不同，它会递归地复制对象及其所有引用类型字段指向的对象，确保新旧对象在内存上完全独立，互不影响。理解这两者的区别，是编写健壮Java代码的关键一步。

解决方案

要实现Java对象的拷贝，我们通常有几种方法，每种都有其适用场景和考量。

浅拷贝的实现方式：

使用 Object.clone() 方法： 这是Java提供的一种标准机制。要使用它，你的类需要实现 Cloneable 接口（这是一个标记接口），并重写 Object 类的 clone() 方法。

class Address {
    String city;
    String street;

    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }

    // Getter, Setter, toString...
    @Override
    public String toString() {
        return "Address{" + "city='" + city + '\'' + ", street='" + street + '\'' + '}';
    }
}

class Person implements Cloneable {
    String name;
    int age;
    Address address; // 引用类型

    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 默认是浅拷贝
    }

    // Getter, Setter, toString...
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + ", address=" + address + '}';
    }
}

// 示例用法
public class ShallowCopyDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address originalAddress = new Address("Beijing", "Chaoyang");
        Person originalPerson = new Person("Zhang San", 30, originalAddress);

        Person clonedPerson = (Person) originalPerson.clone();

        System.out.println("Original: " + originalPerson);
        System.out.println("Cloned: " + clonedPerson);

        // 修改克隆对象的地址
        clonedPerson.address.city = "Shanghai";
        System.out.println("\nAfter modifying cloned person's address:");
        System.out.println("Original: " + originalPerson); // 发现originalPerson的地址也变了
        System.out.println("Cloned: " + clonedPerson);
    }
}

你会发现，originalPerson 的地址也跟着变了，这就是浅拷贝的典型表现。

拷贝构造函数（Copy Constructor）： 为你的类提供一个构造函数，它接受一个同类型的对象作为参数，并将其字段值复制到新创建的对象中。这种方式更显式，也更符合面向对象的设计原则。

class PersonWithCopyConstructor {
    String name;
    int age;
    Address address;

    public PersonWithCopyConstructor(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    // 拷贝构造函数
    public PersonWithCopyConstructor(PersonWithCopyConstructor other) {
        this.name = other.name;
        this.age = other.age;
        this.address = other.address; // 同样是浅拷贝，复制引用
    }
    // Getter, Setter, toString...
}

这种方式在处理引用类型时，同样是浅拷贝。

深拷贝的实现方式：

递归实现 clone() 或拷贝构造函数： 如果你选择 clone() 方法，那么在重写 clone() 时，你需要手动对所有引用类型的字段也进行 clone() 操作。对于拷贝构造函数也是同理，需要为嵌套对象调用它们的拷贝构造函数。

class Address implements Cloneable { // Address也需要实现Cloneable
    String city;
    String street;

    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // Address的浅拷贝就是深拷贝，因为没有更深层次的引用
    }

    // Getter, Setter, toString...
    @Override
    public String toString() {
        return "Address{" + "city='" + city + '\'' + ", street='" + street + '\'' + '}';
    }
}

class PersonDeepClone implements Cloneable {
    String name;
    int age;
    Address address;

    public PersonDeepClone(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        PersonDeepClone clonedPerson = (PersonDeepClone) super.clone(); // 先进行浅拷贝
        clonedPerson.address = (Address) address.clone(); // 对引用类型进行深拷贝
        return clonedPerson;
    }
    // Getter, Setter, toString...
}

// 示例用法
public class DeepCloneDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address originalAddress = new Address("Beijing", "Chaoyang");
        PersonDeepClone originalPerson = new PersonDeepClone("Li Si", 25, originalAddress);

        PersonDeepClone clonedPerson = (PersonDeepClone) originalPerson.clone();

        System.out.println("Original: " + originalPerson);
        System.out.println("Cloned: " + clonedPerson);

        // 修改克隆对象的地址
        clonedPerson.address.city = "Shanghai";
        System.out.println("\nAfter modifying cloned person's address:");
        System.out.println("Original: " + originalPerson); // originalPerson的地址不变
        System.out.println("Cloned: " + clonedPerson);
    }
}

这种方法要求所有涉及深拷贝的类都实现 Cloneable 接口并正确重写 clone() 方法，如果对象图复杂，维护起来会比较麻烦。

通过序列化（Serialization）实现： 这是我个人觉得在很多情况下最“省心”的深拷贝方式，尤其是当你的对象图非常复杂时。它利用了Java的序列化机制，将对象写入一个输出流（比如内存中的字节数组流），然后再从输入流中读回来，这样就得到了一个全新的、独立的深拷贝对象。

import java.io.*;

class AddressSerializable implements Serializable {
    String city;
    String street;

    public AddressSerializable(String city, String street) {
        this.city = city;
        this.street = street;
    }
    // Getter, Setter, toString...
    @Override
    public String toString() {
        return "Address{" + "city='" + city + '\'' + ", street='" + street + '\'' + '}';
    }
}

class PersonSerializable implements Serializable {
    String name;
    int age;
    AddressSerializable address;

    public PersonSerializable(String name, int age, AddressSerializable address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    // Getter, Setter, toString...
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + ", address=" + address + '}';
    }
}

public class DeepCopyBySerialization {
    public static <T extends Serializable> T deepCopy(T obj) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        oos.flush();

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (T) ois.readObject();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        AddressSerializable originalAddress = new AddressSerializable("Guangzhou", "Tianhe");
        PersonSerializable originalPerson = new PersonSerializable("Wang Wu", 35, originalAddress);

        PersonSerializable clonedPerson = deepCopy(originalPerson);

        System.out.println("Original: " + originalPerson);
        System.out.println("Cloned: " + clonedPerson);

        clonedPerson.address.city = "Shenzhen";
        System.out.println("\nAfter modifying cloned person's address:");
        System.out.println("Original: " + originalPerson); // originalPerson的地址不变
        System.out.println("Cloned: " + clonedPerson);
    }
}

这种方法简洁强大，因为它会自动处理对象图中的所有可序列化对象，包括循环引用。但前提是，所有需要深拷贝的对象及其内部的引用对象都必须实现 Serializable 接口。同时，它的性能开销相对较大，因为它涉及I/O操作。

为什么需要区分深拷贝与浅拷贝？

这个问题，其实是Java对象管理的核心痛点之一。想象一下，你有一个User对象，里面包含了UserProfile、Permissions等复杂的引用类型字段。如果你只是简单地做了一个浅拷贝，然后修改了拷贝后的User对象的UserProfile信息，你可能会惊讶地发现，原始的User对象的UserProfile也跟着变了！这就像你影印了一份文件，然后在这份影印件上涂改，结果原件也神奇地被改动了。这种“牵一发而动全身”的行为，在多线程环境或复杂业务逻辑中，往往会引发难以追踪的bug，因为它破坏了数据的独立性。

浅拷贝适用于以下场景：

对象只包含基本数据类型字段，或者所有引用类型字段都是不可变（immutable）的（比如String、Integer等）。
你明确希望新旧对象共享某些引用，因为它们代表的是同一份数据，修改其中一个就是修改共享数据。
性能是首要考虑，并且你知道共享引用不会导致问题。

深拷贝则在以下情况不可或缺：

当你的对象包含可变（mutable）的引用类型字段时，且你希望新旧对象完全独立，互不影响。
你需要创建一个对象的完整快照，以便后续对快照进行修改而不影响原始对象，比如在事务处理中，或者在撤销/重做功能里。
对象的生命周期管理需要明确的独立性。

简单来说，区分它们就是为了避免意外的数据篡改，确保数据在不同操作或不同线程间的隔离性。在我看来，如果拿不准，并且对象结构稍微复杂一点，倾向于深拷贝会更安全，尽管可能带来一点性能开销。

Java中实现深拷贝的常见陷阱与最佳实践

深拷贝虽然强大，但实现起来并非没有坑。我见过不少开发者在这里踩雷，有些坑还挺隐蔽的。

常见陷阱：

Cloneable 的“坑”： Cloneable 只是一个标记接口，它本身不提供任何 clone 的实现。Object.clone() 是 protected 的，这意味着你必须重写它并调用 super.clone()。如果你的类没有实现 Cloneable，调用 super.clone() 会抛出 CloneNotSupportedException。更麻烦的是，如果你忘记在深拷贝中递归地 clone 所有引用类型字段，那么你得到的仍然是浅拷贝，这个错误很常见，而且不容易发现。此外，clone() 方法的返回类型是 Object，需要强制类型转换，这本身就有点不优雅。
序列化性能问题： 虽然序列化实现深拷贝非常方便，但它的性能开销是实实在在的。它涉及到I/O操作（即使是内存中的流），并且需要通过反射来解析对象结构。对于需要频繁进行深拷贝且对象图巨大的场景，序列化可能会成为性能瓶颈。
transient 关键字： 如果你使用序列化方式进行深拷贝，并且对象中某些字段被标记为 transient，那么这些字段在序列化过程中会被忽略，也就不会被拷贝。这通常是故意的，但如果不是，就可能导致数据丢失。
不可序列化的对象： 如果你的对象图中包含任何没有实现 Serializable 接口的类（比如一些第三方库的对象，或者一些I/O流对象），那么使用序列化进行深拷贝时会抛出 NotSerializableException。这要求你对整个对象图的序列化能力有清晰的了解。
final 字段： final 字段在对象构造后就不能再改变。对于深拷贝来说，如果 final 字段是引用类型，并且你试图在拷贝过程中给它赋一个新的引用，这在Java的默认机制下是做不到的。这通常意味着你需要通过拷贝构造函数来处理 final 字段，或者在设计时就避免 final 引用类型字段的深拷贝需求。

最佳实践：

优先使用拷贝构造函数（或工厂方法）： 对于大多数情况，尤其是当你需要对拷贝过程有精细控制时，提供一个拷贝构造函数（或者一个静态的工厂方法，如 copyOf(T original)）是更清晰、更安全的做法。它强制你显式地处理每个字段的拷贝逻辑，包括递归地调用嵌套对象的拷贝构造函数。
考虑不可变对象： 说实话，有时候最好的“拷贝”方式就是根本不需要拷贝。如果你的对象是不可变的（immutable），那么你只需要共享引用即可，因为它的状态永远不会改变，也就没有浅拷贝/深拷贝的困扰。例如，String 类就是不可变的，所以你永远不需要 String 的深拷贝。
序列化作为通用回退方案： 对于那些结构复杂、深度嵌套的对象图，或者你不想手动维护每个类的 clone() 或拷贝构造函数时，序列化深拷贝是一个非常实用的选择。虽然有性能开销，但它的实现成本低，且能自动处理循环引用，这在很多场景下是值得的。
防御性拷贝： 当你的类暴露了可变对象的引用时（例如通过getter方法返回一个List），为了防止外部修改影响内部状态，你应该返回一个拷贝。同样，在构造函数中接收可变对象作为参数时，也应该进行防御性拷贝，避免外部对象的变化影响内部。
文档化拷贝行为： 无论你选择哪种拷贝方式，务必在类的Javadocs中清晰地说明其拷贝行为（是浅拷贝还是深拷贝，以及如何实现）。这对于其他开发者理解和使用你的类至关重要。

选择哪种拷贝方式？性能与复杂度的考量

选择深拷贝的实现方式，说白了就是一场性能与复杂度的权衡游戏。没有银弹，只有最适合你当前场景的方案。

手动拷贝（拷贝构造函数/字段赋值）：
- 性能： 通常是最快的，因为它直接进行内存操作，没有额外的I/O或反射开销。
- 复杂度： 对于简单对象，实现起来非常直观。但如果对象图很复杂，嵌套层级很深，或者字段很多，手动编写和维护这些拷贝逻辑会变得异常繁琐和容易出错。你必须确保所有可变引用都得到了递归的深拷贝。
- 适用场景： 对象结构相对简单，或者你需要对拷贝过程有极致的性能控制和精细化管理时。
Object.clone()：
- 性能： 理论上可以非常快，因为 Object.clone() 是一个 native 方法，可能直接进行内存复制。
- 复杂度： 实现 Cloneable 接口并重写 clone() 方法，对于浅拷贝很简单。但要实现深拷贝，你需要手动递归调用所有引用类型字段的 clone() 方法，这和手动拷贝的复杂度类似，甚至因为 CloneNotSupportedException 和强制类型转换，显得更“笨重”一些。
- 适用场景： 我个人觉得这个方法有点“鸡肋”。它不够灵活，而且容易导致浅拷贝的陷阱。除非你的项目已经大量使用了这种模式，否则我不太推荐新项目以此作为主要深拷贝方式。
序列化（Serializable）：
- 性能： 通常是三种方法中最慢的，因为它涉及到将对象转换为字节流，再从字节流重建对象的过程，这包含了I/O操作和反射开销。
- 复杂度： 实现起来非常简单，只需要让所有相关类实现 Serializable 接口即可。它会自动处理对象图中的所有可序列化对象，包括复杂的循环引用。
- 适用场景： 对象结构非常复杂，嵌套层级深，或者存在循环引用，且对性能要求不是极端苛刻的场景。它能极大地简化深拷贝的实现和维护成本。在我看来，这是在复杂对象图下，实现深拷贝最“省力”且最鲁棒的方式。

我的思考与建议：

在实际开发中，我通常会这样选择：

如果对象是不可变的： 恭喜你，你不需要拷贝！直接传递引用即可。这是最好的情况。
如果对象结构简单，且字段数量不多： 我会优先选择拷贝构造函数。它清晰、直观，性能也很好。
如果对象结构复杂，有深层嵌套，甚至可能存在循环引用： 我会认真考虑使用序列化方式。虽然性能有损耗，但它带来的实现简洁性和健壮性，在很多业务场景下是值得的。当然，我会先评估性能是否能接受。如果性能成为瓶颈，那可能需要重新设计对象结构，或者考虑一些更底层的字节码操作库（比如CGLIB、Objenesis等，但这就超出了一般应用开发的范畴了）。
避免使用 Object.clone()： 除非是在维护遗留代码，或者有非常特殊的性能考量，我通常会避免使用 Object.clone() 来实现深拷贝，它的设计缺陷和使用上的不便，让它在现代Java开发中显得不那么“香”。

总而言之，理解每种拷贝方式的优缺点，并结合你的具体业务场景和性能要求，才能做出最合适的选择。没有一劳永逸的方案，只有不断权衡和优化。

今天关于《Java深浅拷贝详解与实用技巧教程》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！

java 序列化浅拷贝深拷贝对象拷贝