Java-深拷贝、浅拷贝

一、深拷贝、浅拷贝
什么是浅拷贝？
简单点说，
对于简单类型来说，深拷贝拷贝的是值，对于引用类型来说，深拷贝是两个对象两个引用，内容一样
浅拷贝拷贝的是地址（两个引用指向同一个对象）

什么是深拷贝？

二、数组拷贝
数组拷贝有下面四种方法：
如果数组中的值是基本类型，那么就是浅拷贝
如果数组中放的是引用类型，那么就是深拷贝
（1）for
（2）System.arraycopy(src,0,dest,0,length)
（3） Arrays.copyof(int[] original,int newlength)
（4）array.clone()
//存放基本类型（深拷贝，一个数组中某个值的修改不影响另一个数组中的值）

public class Main4 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,2,3};
        show01(arr);
        show02(arr);
        show03(arr);
        show04(arr);
        System.out.println(Arrays.toString(arr));

    }

    private static void show04(int[] arr) {
        int[] newarr=arr.clone();
        newarr[0]=9;
        System.out.println(Arrays.toString(arr));

    }

    private static void show03(int[] arr) {
        int[] newarr= Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(arr));
    }

    private static void show02(int[] arr) {
        int[] newarr=new int[arr.length];
        System.arraycopy(arr,0,newarr,0,arr.length);
        System.out.println(Arrays.toString(arr));


    }

    //for循环进行复制
    private static void show01(int[] arr) {
        int[] newarr=new int[arr.length];
        for(int i=0;i<arr.length;i++){
            newarr[i]=arr[i];
        }
        System.out.println(Arrays.toString(arr));
    }
}

//存放引用类型（浅拷贝，一个数组中某个值改变，拷贝的数组中的对应位置的值也会随之改变，说明拷贝后的对象引用和原对象引用指向了同一个对象）

class Student{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Main5 {
    public static void main(String[] args) {
        Student s1=new Student("张三",29);
        Student s2=new Student("李四",30);
        //创建一个数组，把对象放进去
        Student[] students1=new Student[]{s1,s2};
        Student[] students2= Arrays.copyOf(students1,students1.length);
        System.out.println(Arrays.toString(students1));
        students1[0].name="王五";
        System.out.println(Arrays.toString(students1));
        System.out.println(Arrays.toString(students2));
    }
}

三、那么数组中存放引用类型，如何实现深拷贝呢？
使用Cloneable接口：克隆对象，而不是拷贝地址

class Students implements Cloneable{
    public String name;
    public int age;

    public Students(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Students clone() throws CloneNotSupportedException {
        return (Students)super.clone();
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Main6 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Students s1=new Students("张三",29);
        Students s2= s1.clone();
        System.out.println(s1);
        System.out.println(s2);
        s1.name="王五";
        System.out.println(s1);
        System.out.println(s2);
    }
}

从运行结果可以看到，改变了s1中name属性的值，但是s2中name属性的值并没有随之改变，因此这样就是深拷贝，拷贝的对象，而不是地址。这个过程就是，在堆中重新开辟了一块空间，将s1中的内容复制过去，将新的地址返回给s2。