Java中的深拷贝与浅拷贝小结

一、浅拷贝与深拷贝理解

数据类型分为基本数据类型和引用数据类型。
基本数据类型直接存储在栈中，而引用数据类型则在堆中存储真实数据，在栈中存储堆中的地址。解释器需要先获取栈中指针，通过指针找到堆中的真实数据。

深拷贝和浅拷贝示意图如下所示：

浅拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，如果字段是值类型的，那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。因此，原始对象及其副本引用同一个对象。
深拷贝：创建一个新对象，然后将当前对象的非静态字段复制到该新对象，无论该字段是值类型的还是引用类型，都复制独立的一份。当你修改其中一个对象的任何内容时，都不会影响另一个对象的内容。

二、赋值与浅拷贝

赋值和原始对象指向的是同一对象，而浅拷贝中，创建了新对象，对基本数据类型进行了赋值，对引用数据类型赋值了其引用，因此，和原始数据中的引用数据类型指向的是同一内存。

三、Java中浅拷贝的实现

调用 Object 类的 clone() 方法来完成，让类实现 Cloneable 接口，并且覆写 clone 方法。
例子如下：

public class Person implements Cloneable{
    public String pname;
    public int page;
    public Address address;
    public Person() {}
    
    public Person(String pname,int page){
        this.pname = pname;
        this.page = page;
        this.address = new Address();
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    public void setAddress(String provices,String city ){
        address.setAddress(provices, city);
    }
    public void display(String name){
        System.out.println(name+":"+"pname=" + pname + ", page=" + page +","+ address);
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public int getPage() {
        return page;
    }

    public void setPage(int page) {
        this.page = page;
    }
    
}

public class Address {
    private String provices;
    private String city;
    public void setAddress(String provices,String city){
        this.provices = provices;
        this.city = city;
    }
    @Override
    public String toString() {
        return "Address [provices=" + provices + ", city=" + city + "]";
    }
    
}

测试：

public void testShallowClone() throws Exception{
    Person p1 = new Person("zhangsan",21);
    p1.setAddress("湖北省", "武汉市");
    Person p2 = (Person) p1.clone();
    System.out.println("p1:"+p1);
    System.out.println("p1.getPname:"+p1.getPname().hashCode());
    
    System.out.println("p2:"+p2);
    System.out.println("p2.getPname:"+p2.getPname().hashCode());
    
    p1.display("p1");
    p2.display("p2");
    p2.setAddress("湖北省", "荆州市");
    System.out.println("将复制之后的对象地址修改：");
    p1.display("p1");
    p2.display("p2");
}

四、Java中深拷贝的实现

以下总结两种实现方法：

4.1 重写每个引用类型属性的clone()方法

对每个引用类型属性的clone()方法重写，相当于将每个引用类型属性拆分成基本类型，分别进行浅拷贝。
例子如下：

对People中的Address引用类型重写clone()

 3 public class Address implements Cloneable{
 4     private String provices;
 5     private String city;
 6     public void setAddress(String provices,String city){
 7         this.provices = provices;
 8         this.city = city;
 9     }
10     @Override
11     public String toString() {
12         return "Address [provices=" + provices + ", city=" + city + "]";
13     }
14     @Override
15     protected Object clone() throws CloneNotSupportedException {
16         return super.clone();
17     }
18     
19 }

People中重写clone()

1     @Override
2     protected Object clone() throws CloneNotSupportedException {
3         Person p = (Person) super.clone();
4         p.address = (Address) address.clone();
5         return p;
6     }

如果Address中海油引用类型，要继续逐个重写，因此，这个使用这个方法如果遇到大量的嵌套引用类型，就很麻烦。
推荐使用下面的序列化方法重写。

4.2 序列化

把原始对象写入到一个字节流中，再从字节流中将其读出来，这样就可以创建一个新的对象了，并且该新对象与母对象之间并不存在引用共享的问题，真正实现对象的深拷贝。
例子如下：

public class CloneUtils {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T clone(T obj){
        T cloneObj = null;
        try {
            //写入字节流
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ObjectOutputStream obs = new ObjectOutputStream(out);
            obs.writeObject(obj);
            obs.close();
            
            //分配内存，写入原始对象，生成新对象
            ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(ios);
            //返回生成的新对象
            cloneObj = (T) ois.readObject();
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cloneObj;
    }
}

参考资料

https://www.jianshu.com/p/35d69cf24f1f
https://www.cnblogs.com/williamjie/p/11192895.html
https://www.cnblogs.com/ysocean/p/8482979.html
https://blog.csdn.net/weixin_40581980/article/details/81388557