java浅拷贝和深拷贝

Java中的对象拷贝有两种方式：浅拷贝和深拷贝。

浅拷贝是指在拷贝对象时，只复制对象本身和其中的基本数据类型的属性，而引用类型的属性并不会被复制，新对象和原对象会共用同一个引用类型的属性。浅拷贝可以通过Object类的clone()方法实现。

深拷贝是指在拷贝对象时，不仅复制对象本身和其中的基本数据类型的属性，还会递归复制对象中的引用类型的属性，新对象和原对象不共用任何属性。深拷贝可以通过序列化和反序列化实现，也可以通过手动编写代码实现。

需要注意的是，如果对象中的引用类型的属性也需要被复制，那么这个引用类型必须是可序列化的。否则，手动编写代码实现深拷贝可能会更加复杂。

相关问题

java 浅拷贝和深拷贝

在 Java 中，对象的拷贝可以分为浅拷贝和深拷贝。

浅拷贝是指创建一个新的对象，然后将原始对象的非静态字段复制到新对象中。如果字段是基本类型，则复制其值；如果字段是引用类型，则复制其引用，因此新对象和原始对象将共享引用类型字段所引用的对象。Java 中的 `clone()` 方法提供了浅拷贝的实现。

深拷贝是指创建一个新的对象，然后将原始对象的非静态字段复制到新对象中，并且递归地复制引用类型字段所引用的对象。因此，新对象和原始对象将不共享任何引用类型字段所引用的对象。Java 中可以通过序列化和反序列化实现深拷贝。

需要注意的是，如果一个类中有引用类型的字段，并且这个引用类型没有实现 Cloneable 接口，那么使用 `clone()` 方法进行浅拷贝时，会抛出 `CloneNotSupportedException` 异常。此时，可以考虑使用深拷贝来复制对象。

java 浅拷贝和深拷贝 示例

在 Java 中，对象的拷贝分为浅拷贝和深拷贝两种。浅拷贝只是拷贝了对象的引用，而不是对象本身；深拷贝则是拷贝了对象本身，包括对象中的所有属性。

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

class Person implements Cloneable {
    private String name;
    private int age;
    private Address address;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Address getAddress() {
        return address;
    }

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

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

class Address {
    private String city;

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

    public String getCity() {
        return city;
    }

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

在这个示例中，`Person` 类包含一个 `Address` 对象。下面分别展示了浅拷贝和深拷贝的实现方式。

浅拷贝示例：

Person person1 = new Person("Tom", 20, new Address("Beijing"));
Person person2 = (Person) person1.clone();

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

// person1 和 person2 的地址都变成了 Shanghai
System.out.println(person1.getAddress().getCity()); // 输出 Shanghai
System.out.println(person2.getAddress().getCity()); // 输出 Shanghai

在上面的示例中，`person2` 是通过 `person1` 进行浅拷贝得到的，因此它们的地址是相同的。当我们修改 `person2` 的地址时，`person1` 的地址也被修改了。

深拷贝示例：

public class DeepCopyDemo {
    public static void main(String[] args) throws Exception {
        Person person1 = new Person("Tom", 20, new Address("Beijing"));
        Person person2 = (Person) deepCopy(person1);

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

        // person1 的地址没有变化
        System.out.println(person1.getAddress().getCity()); // 输出 Beijing
        System.out.println(person2.getAddress().getCity()); // 输出 Shanghai
    }

    private static Object deepCopy(Object obj) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);

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

在上面的示例中，我们使用了 Java 提供的序列化和反序列化机制来实现深拷贝。通过将对象写入一个 `ByteArrayOutputStream` 中，然后再从一个 `ByteArrayInputStream` 中读取对象，就可以得到一个新的、深拷贝的对象。