java实现浅拷贝与深拷贝

目录

浅拷贝

 深拷贝

实现cloneable接口

序列化

---

浅拷贝

浅拷贝是指创建一个新的对象，该对象的内容是原始对象中各项的引用。换句话说，浅拷贝仅复制了原始对象中元素的引用，而不是元素本身的拷贝

class  People implements Cloneable{
    private String name;
    private int  age;
    private Address address;
    public People(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address.toString() +
                '}';
    }

    public Address getAddress() {
        return address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Address{
    private String city;

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                '}';
    }

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

    public void setCity(String city) {
        this.city = city;
    }
}
public class Clone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address=new Address("杭州");
        People people=new People("李飞",22,address);
        People clonePeople= (People) people.clone();
        System.out.println(people);
        System.out.println(clonePeople);
        //修改 address 值
        address.setCity("北京");
        System.out.println(people);
        System.out.println(clonePeople);
        System.out.println(clonePeople.getAddress().hashCode());
        System.out.println(people.getAddress().hashCode());
    }
}

运行结果：

　      原始类 Person 实现 Cloneable 接口，并且覆写 clone 方法,它还有三个属性，一个引用类型 String定义的 name，一个基本类型 int定义的age，还有一个引用类型 Address ，这是一个自定义类，这个类包含 city 属性。

　　当我修改了原对象的Address中的city属性（从杭州变更为北京），从输出结果来看，克隆对象的city属性也发生了改变，然后又打印了原对象和克隆对象的Address的哈希地址，发现他们还是同一个对象。这就是浅拷贝，对于引用型对象只会复制引用，他们指向的还是同一块堆内存空间，而不是创建一个新的对象。

 深拷贝

深拷贝是指创建一个新的对象，并递归地复制原始对象及其所有嵌套对象，从而实现完全独立的拷贝。对原对象的操作不会影响新对象。

实现cloneable接口

那如果实现深拷贝呢，第一种方法就是复制对象里的所有引用对象都实现cloneable接口并重写clone 方法就行，这里的自定义的引用对象就是Address,当我们将该对象也实现cloneable接口，就可以实现深拷贝了

package base;

class  People implements Cloneable{
    // People其他属性没展示，可参考上面代码
    @Override
    protected Object clone() throws CloneNotSupportedException {
        People people =(People) super.clone();
        people.address = (Address) address.clone();
        return people;
    }
}
class Address implements Cloneable{
    private String city;

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                '}';
    }

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

    public void setCity(String city) {
        this.city = city;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Clone {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address=new Address("杭州");
        People people=new People("李飞",22,address);
        People clonePeople= (People) people.clone();
        System.out.println(people);
        System.out.println(clonePeople);
        //修改 address 值
        address.setCity("北京");
        System.out.println(people);
        System.out.println(clonePeople);
        System.out.println(clonePeople.getAddress().hashCode());
        System.out.println(people.getAddress().hashCode());
    }
}

执行结果：

上面主要修改点一个就是Address也实现了 cloneable接口，重写了clone 方法，然后People中clone方法进行了修改，调用了Address的clone方法。

        但是这种做法有个弊端，这里我们Person 类只有一个 Address 引用类型，而 Address 类没有，所以我们只用重写 Address 类的clone 方法，但是如果 Address 类也存在一个引用类型，那么我们也要重写其clone 方法，这样下去，有多少个引用类型，我们就要重写多少次，如果存在很多引用类型，那么代码量显然会很大，所以这种方法不太合适。

序列化

        序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。这里写到流中的对象则是原始对象的一个拷贝，因为原始对象还存在 JVM 中，所以我们可以利用对象的序列化产生克隆对象，然后通过反序列化获取这个对象。

        注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。

    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

完整代码：

class  People implements Serializable {
    private String name;
    private int  age;
    private Address address;
    public People(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address.toString() +
                '}';
    }

    public Address getAddress() {
        return address;
    }
    public Object deepClone() throws Exception{
        // 序列化
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        // 反序列化
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}
class Address implements Serializable{
    private String city;

    @Override
    public String toString() {
        return "Address{" +
                "city='" + city + '\'' +
                '}';
    }

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

    public void setCity(String city) {
        this.city = city;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Clone {

    public static void main(String[] args) throws Exception {
        Address address=new Address("杭州");
        People people=new People("李飞",22,address);
        People clonePeople= (People) people.deepClone();
        System.out.println(people);
        System.out.println(clonePeople);
        //修改 address 值
        address.setCity("北京");
        System.out.println(people);
        System.out.println(clonePeople);
        System.out.println(clonePeople.getAddress().hashCode());
        System.out.println(people.getAddress().hashCode());
    }
}

运行结果：