java对象拷贝(代码示例)

Java中的对象拷贝是指创建一个新的对象，使其拥有与原始对象相同的属性值。对象拷贝可以通过两种方式实现：浅拷贝和深拷贝。

浅拷贝是指创建一个新对象，然后将原始对象的属性值复制给新对象。新对象和原始对象将共享相同的引用类型属性，即它们指向相同的内存地址。当修改新对象的引用类型属性时，原始对象的属性也会被修改。浅拷贝可以通过实现Cloneable接口并重写clone()方法来实现。

示例代码如下：

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;
    }
    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }
}
class Address {
    private String city;
    public Address(String city) {
        this.city = city;
    }
    public String getCity() {
        return city;
    }
}
public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", 20, address);
        Person person2 = person1.clone();
        System.out.println(person1.getName()); // Alice
        System.out.println(person2.getName()); // Alice
        person2.getName().toUpperCase();
        System.out.println(person1.getName()); // Alice
        System.out.println(person2.getName()); // ALICE
        System.out.println(person1.getAddress().getCity()); // Beijing
        System.out.println(person2.getAddress().getCity()); // Beijing
        person2.getAddress().city = "Shanghai";
        System.out.println(person1.getAddress().getCity()); // Shanghai
        System.out.println(person2.getAddress().getCity()); // Shanghai
    }
}

深拷贝是指创建一个新对象，并将原始对象的属性值复制给新对象。新对象和原始对象拥有相同的属性值，但是它们指向不同的内存地址。当修改新对象的引用类型属性时，原始对象的属性不会被修改。深拷贝可以通过实现Serializable接口并使用序列化和反序列化来实现，或者通过手动递归拷贝对象的所有引用类型属性来实现。

示例代码如下：

import java.io.*;
class Person implements Serializable {
    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;
    }
}
class Address implements Serializable {
    private String city;
    public Address(String city) {
        this.city = city;
    }
    public String getCity() {
        return city;
    }
}
public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Address address = new Address("Beijing");
        Person person1 = new Person("Alice", 20, address);
        // 使用序列化和反序列化进行深拷贝
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(person1);
        oos.flush();
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Person person2 = (Person) ois.readObject();
        System.out.println(person1.getName()); // Alice
        System.out.println(person2.getName()); // Alice
        person2.getName().toUpperCase();
        System.out.println(person1.getName()); // Alice
        System.out.println(person2.getName()); // Alice
        System.out.println(person1.getAddress().getCity()); // Beijing
        System.out.println(person2.getAddress().getCity()); // Beijing
        person2.getAddress().city = "Shanghai";
        System.out.println(person1.getAddress().getCity()); // Beijing
        System.out.println(person2.getAddress().getCity()); // Shanghai
    }
}

以上示例代码中，浅拷贝通过调用`clone()`方法实现，深拷贝通过序列化和反序列化实现。通过修改新对象的引用类型属性，可以观察到浅拷贝和深拷贝的不同效果。