当前位置：首页 > 文章列表 > 文章 > java教程 > Java深拷贝和浅拷贝傻傻分不清？一文帮你彻底搞懂！

Java深拷贝和浅拷贝傻傻分不清？一文帮你彻底搞懂！

2025-06-13 13:28:21 0浏览收藏

一分耕耘，一分收获！既然都打开这篇《Java深拷贝与浅拷贝的区别，搞懂复制背后的奥秘》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新文章相关的内容，希望对大家都有所帮助！

深拷贝与浅拷贝的关键区别在于是否复制对象内部的引用对象。1. 浅拷贝仅复制对象的非引用类型字段，引用类型字段则共享同一地址，修改一个对象的引用字段会影响其他对象；2. 深拷贝递归复制所有引用对象，生成完全独立的新对象，修改新对象不影响原对象。3. 实现深拷贝的方式包括手动递归复制、重写 clone() 方法、序列化与反序列化、使用第三方库等。4. 选择拷贝方式需根据场景决定：浅拷贝适用于引用对象不可变或需要共享的情况，深拷贝适用于需完全独立的场景。5. 实现深拷贝时需注意循环引用问题，可通过缓存已复制对象避免无限递归。6. 深拷贝性能开销较大，在高性能场景中应谨慎使用或采用优化策略。

Java中深拷贝和浅拷贝的区别分析复制差异

深拷贝和浅拷贝，关键在于拷贝对象时，是否复制了对象内部的引用对象。浅拷贝只复制引用，深拷贝则会递归地复制所有引用对象，生成全新的独立对象。

深拷贝和浅拷贝的区别，本质上是对对象内部引用类型的处理方式不同。

浅拷贝的陷阱：共享的引用

浅拷贝，也叫影子拷贝，创建新对象时，只复制原始对象的非引用类型字段的值。对于引用类型字段，新对象只是复制了引用地址，这意味着新对象和原始对象共享同一个引用对象。修改其中一个对象的引用对象，另一个对象也会受到影响。例如：

class Address {
    String city;

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

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

class Person {
    String name;
    Address address;

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

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    // 浅拷贝方法
    public Person shallowCopy() {
        return new Person(this.name, this.address);
    }
}

public class Main {
    public static void main(String[] args) {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address);

        Person person2 = person1.shallowCopy();

        // 修改 person2 的地址
        person2.getAddress().setCity("Shanghai");

        System.out.println("Person1's city: " + person1.getAddress().getCity()); // 输出 Shanghai
        System.out.println("Person2's city: " + person2.getAddress().getCity()); // 输出 Shanghai
    }
}

可以看到，修改person2的地址后，person1的地址也跟着改变了。这就是浅拷贝的副作用，多个对象共享同一个内部引用对象。

实现深拷贝的几种方式

深拷贝则会完全复制原始对象及其所有引用对象，生成一个全新的、完全独立的对象。修改新对象不会影响原始对象。实现深拷贝的方法有几种：

手动实现： 递归地复制每一个引用类型的字段。这是最直接但也是最繁琐的方式。

class Address implements Cloneable {
    String city;

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

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public Address clone() {
        try {
            return (Address) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

class Person implements Cloneable {
    String name;
    Address address;

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

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    // 深拷贝方法
    @Override
    public Person clone() {
        try {
            Person cloned = (Person) super.clone();
            cloned.address = this.address.clone(); // 关键：复制 Address 对象
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address);

        Person person2 = person1.clone();

        // 修改 person2 的地址
        person2.getAddress().setCity("Shanghai");

        System.out.println("Person1's city: " + person1.getAddress().getCity()); // 输出 Beijing
        System.out.println("Person2's city: " + person2.getAddress().getCity()); // 输出 Shanghai
    }
}

使用 clone() 方法： 让类实现 Cloneable 接口，并重写 clone() 方法。但需要注意，clone() 方法默认是浅拷贝，需要手动实现深拷贝逻辑。上面的代码示例已经展示了如何使用clone()方法实现深拷贝。
序列化和反序列化： 将对象序列化成字节流，再反序列化成新的对象。这种方式可以实现完全的深拷贝，但性能相对较低。需要类实现 Serializable 接口。

import java.io.*;

class Address implements Serializable {
    String city;

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

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

class Person implements Serializable {
    String name;
    Address address;

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

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    // 深拷贝方法 (使用序列化)
    public Person deepCopy() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (Person) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", address);

        Person person2 = person1.deepCopy();

        // 修改 person2 的地址
        person2.getAddress().setCity("Shanghai");

        System.out.println("Person1's city: " + person1.getAddress().getCity()); // 输出 Beijing
        System.out.println("Person2's city: " + person2.getAddress().getCity()); // 输出 Shanghai
    }
}