Java中的深拷贝和浅拷贝_深拷 和浅拷 java

浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址，

深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，

使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。

浅复制：仅仅是指向被复制的内存地址，如果原地址发生改变，那么浅复制出来的对象也会相应的改变。

深复制：在计算机中开辟一块新的内存地址用于存放复制的对象。

---

在Java中，深拷贝和浅拷贝是用于复制对象的两种不同方式。

浅拷贝（Shallow Copy）是指创建一个新对象，然后将原始对象的字段值复制给新对象。如果字段是基本数据类型，那么复制的是字段的值；如果字段是引用类型，那么复制的是引用的地址，即两个对象将共享同一个引用对象。简而言之，浅拷贝只复制对象的引用，而不复制引用指向的对象本身。

深拷贝（Deep Copy）是指创建一个新对象，并递归地复制原始对象及其所有引用的对象。这意味着在深拷贝中，除了复制对象本身的字段值外，还会复制对象引用的所有对象。换句话说，深拷贝会创建一个独立的、完全拷贝的对象，与原始对象完全独立，互不影响。

下面是深拷贝和浅拷贝的示例代码：

// 示例类
class Person implements Cloneable {
    private String name;
    private Address address;

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

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", address=" + address + "]";
    }
}

class Address {
    private String city;

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

    @Override
    public String toString() {
        return "Address [city=" + city + "]";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

使用浅拷贝：

public class ShallowCopyExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("City");
        Person person1 = new Person("John", address);

        Person person2 = (Person) person1.clone();

        System.out.println(person1);
        System.out.println(person2);

        // 修改person1的地址对象
        address.setCity("New City");

        System.out.println(person1);
        System.out.println(person2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果：

Person [name=John, address=Address [city=City]]
Person [name=John, address=Address [city=City]]
Person [name=John, address=Address [city=New City]]
Person [name=John, address=Address [city=New City]]
1
2
3
4

可以看到，使用浅拷贝后，person1和person2共享同一个地址对象。当修改person1的地址对象时，person2的地址对象也会受到影响。

使用深拷贝：

public class DeepCopyExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("City");
        Person person1 = new Person("John", address);

        Person person2 = (Person) person1.clone();

        System.out.println(person1);
        System.out.println(person2);

        // 修改person1的地址对象
        address.setCity("New City");

        System.out.println(person1);
        System.out.println(person2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果：

Person [name=John, address=Address [city=City]]
Person [name=John, address=Address [city=City]]
Person [name=John, address=Address [city=City]]
Person [name=John, address=Address [city=City]]
1
2
3
4

可以看到，使用深拷贝后，person1和person2拥有独立的地址对象。即使修改person1的地址对象，person2的地址对象仍保持不变。

需要注意的是，实现深拷贝的方式有多种，例如通过序列化和反序列化、递归拷贝对象等。在示例中，我们使用了clone()方法来实现深拷贝，但需要确保被拷贝的类及其引用的类都实现了Cloneable接口，并正确地重写了clone()方法。

总结而言，深拷贝复制对象及其引用的对象的所有内容，而浅拷贝只复制对象本身，对象引用仍然是共享的。选择使用深拷贝还是浅拷贝取决于具体需求和对象之间的关系，以确保在程序中正确处理对象的拷贝和引用。