总结很多很多的区别(持续更新)3.深拷贝和浅拷贝

一、拷贝的初印象
首先我们先区分一下拷贝和赋值,拿数组来说,拷贝就会新开辟一块数组来存放和原始数组相同的数据,而赋值不同,只是在栈上,将原始数组名中引用的地址直接传给新的数组名,这样新的数组对数组内的数据进行更改是一定会影响原始数组的.总的来说赋值就是复制对象空间而不复制资源
在对Java的初始过程中,我们知道Java的数据类型分为基本数据类型和引用数据类型。在写代码的过程中进行赋值、传参或作为返回值时,就会发生值传递和地址传递这两种情况。
拿数组的拷贝来举个例子:
先上两段代码(存放简单类型和引用类型):

 public static void main(String[] args) {
        int[]arr1={1,2,3,4};
        int[]arr2=new int[arr1.length];
        System.out.println(Arrays.toString(arr1));
        System.arraycopy(arr1,0,arr2,0,arr1.length );
        arr2[2]=999;
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
    }

它运行的结果是这样的:

[1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 999, 4]

存放引用类型时:

class A{
    private int c=4;
    public void change(int s){
        this.c=s;
    }
    @Override
    public String toString() {
        return "A{" +
                "c=" + c +
                '}';
    }
}
public class Main {
    public static void main(String[] args) {
        A a=new A();
        A b=new A();
        A c=new A();
        A d=new A();
        A[] array={a,b,c,d};
        A[] dest= new A[array.length];
        System.arraycopy(array,0,dest,0,array.length );
        System.out.println("dest"+Arrays.toString(dest));
        System.out.println("array"+Arrays.toString(array));
        dest[2].change(999);
        System.out.println("dest"+ Arrays.toString(dest));
        System.out.println("array"+ Arrays.toString(array));
    }
}

它运行的结果是这样的:

dest[A{c=4}, A{c=4}, A{c=4}, A{c=4}]
array[A{c=4}, A{c=4}, A{c=4}, A{c=4}]
dest[A{c=4}, A{c=4}, A{c=999}, A{c=4}]
array[A{c=4}, A{c=4}, A{c=999}, A{c=4}]

对于这里我要插一条与本篇博客主题无关的小tips哦!
我们知道println的源码是会调用obj的toString方法,当我们自定义类使用toString方法输出时,都会重写这个方法,否则的话就会按照object的toString来输出类型@哈希码,那为什么我们直接把数组名放进输出函数没有办法调用数组的toString方法呢,打开Arrays.toString的源码发现,它并不是重写object而来的,所以数组转为字符串应写成：Arrays.toString(a)

 public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }

回归正题:当数组中存放简单类型修改拷贝后的数组不会影响原始数组,而存放引用类型的时候修改拷贝后的数组,原始数组会同时改变,前者就是深拷贝,后者就是浅拷贝.如图:

对于简单类型来说这就是深拷贝,对于引用来说如下,就是浅拷贝,a,b,c,d都是引用,存的是地址,原始数组经过拷贝后都是指向同一对象,浅拷贝会带来安全隐患,例如我们只是想修改拷贝后的二号下标的对象中C的值,但原始数组也被修改了，因为它们都是指向的同一个地址.为此我们需要用到深拷贝.

二、深拷贝的实现
深拷贝的实现我们也需要借助到Cloneable接口,不同的是要让所有的类都实现cloneable接口,关于Cloneable接口,它是一个空接口,也就是个标志接口,如果一个类实现了cloneable接口代表这个类可以被clone,在实现接口的时候我们要重写object的克隆方法,看下面这个例子:

class Money implements Cloneable{
    public int money=11;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}
class Person implements Cloneable{
    public int age;
    public Money m;
    public Person(int age) {
        this.age = age;
        m=new Money();
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person person1=(Person)super.clone();//克隆一份person
        person1.m=(Money)this.m.clone();//拷贝money 再赋值给新的
        return person1;
    }
}
public class TestDemo28 {

    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person(10);
        Person person1 = (Person) person.clone();
        System.out.println(person.m.money);
        System.out.println(person1.m.money);
        System.out.println("=========通过person1修改money========");
        person1.m.money=9999;
        System.out.println(person.m.money);
        System.out.println(person1.m.money);
    }

以上代码打印的结果是:

11
11
=========通过person1修改money========
11
9999

我们可以看到对于有多层对象的,每个对象都需要实现 Cloneable 并重写 clone() 方法,进而实现对对象的层层拷贝.说的明白点就是,我们在拷贝的过程中,要把每个对象都实现拷贝,就如图一样:

如上的代码中如果只有person类实现了cloneable,而money没有实现,那就是只实现了浅拷贝,m指向的地址还是相同的.
三、总结关于深拷贝、浅拷贝
(1) 对于基本数据类型的成员对象,因为他们是按值传递的,所以是直接将属性值赋值给新的对象。
(2) 对于引用类型,通过clone方法去拷贝里面的内容,如果里面存储的数据成员是基本数据类型,改变其中一个，不会对另外一个也产生影响.这是深拷贝
(3) 对于有多重对象的,(Person中有Money)每个对象都需要实现 Cloneable 并重写 clone() 方法，进而实现了对象的层层拷贝.这是深拷贝.而浅拷贝只是把内存地址赋值给了成员变量，指向了同一内存空间.改变其中一个,会影响另外一个.