Java中的深拷贝和浅拷贝

在Java中，当我们需要复制一个对象时，我们需要考虑两种拷贝方式：浅拷贝和深拷贝。这两种拷贝方式的主要区别在于它们如何处理对象的引用类型属性。

浅拷贝是创建一个新的对象，并将原对象的非静态字段的值复制到新对象中。对于引用类型的字段，浅拷贝只会复制引用，而不是引用的对象本身。因此，如果原对象的引用类型字段指向了一个可变对象，那么在新对象和原对象之间，这两个对象将共享同一个可变对象。也就是说浅拷贝的话原对象改变浅拷贝也会改变

深拷贝是创建一个新的对象，并递归地复制原对象的所有字段。对于引用类型的字段，深拷贝会创建一个新的引用对象，并将原对象的引用对象复制到新的引用对象中。这样，即使原对象的引用类型字段指向了一个可变对象，那么在新对象和原对象之间，这两个对象将不再共享同一个可变对象。也就是说原对象和深拷贝是两个对象，互相不打扰

下面是一个示例代码，展示了如何在Java中实现深拷贝和浅拷贝：

import java.util.ArrayList;
import java.util.List;

class Address implements Cloneable {
    private String city;
    private String street;

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

    public void setStreet(String street) {
        this.street = street;
    }

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

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

    public String getCity() {
        return city;
    }

    public String getStreet() {
        return street;
    }
}

public class Person implements Cloneable {
    private String name;
    private List
 addresses;

    public Person(String name, List
 addresses) {
        this.name = name;
        this.addresses = addresses;
    }

    public String getName() {
        return name;
    }

    public List
 getAddresses() {
        return addresses;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        cloned.addresses = new ArrayList<>(this.addresses); // 浅拷贝
        return cloned;
    }

    public Object deepClone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();
        List
 clonedAddresses = new ArrayList<>();
        for (Address address : this.addresses) {
            clonedAddresses.add((Address) address.clone()); // 深拷贝
        }
        cloned.addresses = clonedAddresses;
        return cloned;
    }

    public static void main(String[] args) {
        List
 addresses = new ArrayList<>();
        addresses.add(new Address("BeiJing", "123 Street"));
        addresses.add(new Address("TianJin", "456 Avenue"));
        Person person1 = new Person("Alice", addresses);

        try {
            Person person2 = (Person) person1.clone(); // 浅拷贝
            Person person3 = (Person) person1.deepClone(); // 深拷贝
            System.out.println("修改前Person1: " + person1.getAddresses().get(0).getCity()); // 输出被修改后的地址
            System.out.println("修改前Person2: " + person2.getAddresses().get(0).getCity()); // 输出被修改后的地址
            System.out.println("修改前Person3: " + person3.getAddresses().get(0).getCity()); // 输出未被修改的原始地址

            // 修改person1的地址
            person1.getAddresses().get(0).setCity("ShangHai") ;

            System.out.println("修改后Person1: " + person1.getAddresses().get(0).getCity()); // 输出被修改后的地址
            System.out.println("修改后Person2: " + person2.getAddresses().get(0).getCity()); // 输出被修改后的地址
            System.out.println("修改后Person3: " + person3.getAddresses().get(0).getCity()); // 输出未被修改的原始地址
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

在这个示例中，我们创建了一个Person类和一个Address类。Person类包含一个addresses列表，用于存储Address对象。我们在Person类中实现了clone()方法来实现浅拷贝，以及deepClone()方法来实现深拷贝。在main()方法中，我们创建了一个Person对象，并对其进行了浅拷贝和深拷贝操作。然后，我们修改了person1的地址，并观察了不同拷贝方式下的结果。