java浅复制和深复制的区别

时间:2022-09-14 22:30:47

一、基本数据类型 & 引用类型

1.1 基本概念

在讨论 浅拷贝 & 深拷贝 这个问题之前,我们需要先了解 基本数据类型 & 引用类型 这两者之间的区别,否则后面会很疑惑。在Java当中,这两类的代表分别为:

  • 八种 基本数据类型:byteshortintlongfloatdoublecharboolean
  • 引用类型:除去基本数据类型的其它类型都是引用数据类型,例如类、接口、数组。

(1) JAVA 基本数据类型与引用数据类型 一文中总结了这两者的区别:

基本数据类型 引用数据类型
变量名指向具体的数值 变量名指向存数据对象的内存地址,即变量名指向hash
变量在声明之后就会立刻分配给他内存空间 它以特殊的方式指向对象实体,这类变量声明时不会分配内存,只是存储了一个内存地址
基本类型之间的赋值是创建新的拷贝 对象之间的赋值只是传递引用
“==”和“!=”是在比较值 “==”“!=”是在比较两个引用是否相同
使用时需要赋具体值,判断时使用== 使用时可以赋值null,判断时使用equals方法

1.2 基本数据类型 和 引用数据类型 传递区别

程序设计语言中有关参数传递给方法的两个专业术语是:

  • 按值调用:表示方法接收的是调用者提供的值。
  • 按引用调用:表示方法接收的是调用者提供的变量的地址。

Java不存在按引用调用,也就是说,假如方法传递的是一个引用数据类型,那么可以修改 引用所指向的对象的属性,但不能 让引用指向其它的对象

1.2.1 传递基本数据类型

    public static void methodBasic() {
        int lNum = 3;
        methodRunInner(lNum);
        Log.d("CopySample", "After methodRunInner, lNum=" + lNum);
    }

    private static void methodRunInner(int lNum) {
        lNum++;
        Log.d("CopySample", "methodRunInner, lNum=" + lNum);
    }
java浅复制和深复制的区别
传递基本数据类型

1.2.2 传递引用数据类型

当传递的是引用数据类型,可以在函数中修改该引用所指向的对象的成员变量的值,如下所示:

    public static void methodRef() {
        NumHolder holder = new NumHolder();
        holder.num = 3;
        methodRunInner(holder);
        Log.d("CopySample", "After methodRunInner, holder.num=" + holder.num);
    }

    private static void methodRunInner(NumHolder holder) {
        holder.num++;
        Log.d("CopySample", "methodRunInner, holder.num=" + holder.num);
    }

    private static class NumHolder {
        int num;
    }
java浅复制和深复制的区别
传递引用数据类型

但是,我们并不能让引用指向其它的对象,例子如下所示:

    public static void methodSwapRef() {
        NumHolder lHolder = new NumHolder();
        NumHolder rHolder = new NumHolder();
        lHolder.num = 3;
        rHolder.num = 4;
        methodRunInner(lHolder, rHolder);
        Log.d("CopySample", "methodSwapRef, lHolder.num=" + lHolder.num  + ", rHolder.num=" + rHolder.num);
    }

    private static void methodRunInner(NumHolder lHolder, NumHolder rHolder) {
        NumHolder temp = lHolder;
        lHolder = rHolder;
        rHolder = temp;
        Log.d("CopySample", "methodRunInner, lHolder.num=" + lHolder.num  + ", rHolder.num=" + rHolder.num);
    }

    private static class NumHolder {
        int num;
    }
java浅复制和深复制的区别
在方法中交换引用

二、浅拷贝 Vs 深拷贝

在对基本数据类型和引用数据类型了解之后,我们就可以开始分析浅拷贝 & 深拷贝了。

2.1 定义

首先让我们来看一下它们俩的定义:

  • 浅拷贝:使用一个已知实例对新创建实例的成员变量逐个 赋值,这个方式被称为浅拷贝。
  • 深拷贝:当一个类的拷贝构造方法,不仅要复制对象的所有非引用成员变量值,还要为引用类型的成员变量创建新的实例,并且初始化为形式参数实例值。

2.2 赋值操作符 =

上面我们讲到了一个关键词 - 赋值,那么让我们来先看一下赋值操作符=在基本数据类型和引用数据类型上会发生什么。

2.2.1 基本数据类型

    public static void startRun1() {
        int lNumber = 2;
        int rNumber = lNumber;
        rNumber = 3;
        Log.d("CopySample", "lNumber=" + lNumber + ",rNumber=" + rNumber);
    }

运行结果为:

java浅复制和深复制的区别
基本数据类型 - 赋值结果

对于基本数据类型,当我们用 rNumberlNumber进行赋值的时候,实际上是开辟了一块新的内存空间,因此对于 rNumber的改变,并不会影响 lNumber

2.2.2 引用数据类型

    public static void startRun2() {
        People lPeople = new People();
        lPeople.age = 10;
        People rPeople = lPeople;
        rPeople.age = 20;
        Log.d("CopySample", "lPeople=" + lPeople + ",lPeople.age=" + lPeople.age + ",\n" +
            "rPeople=" + rPeople + ",rPeople.age=" + rPeople.age);
    }

    public static class People {
        int age;
    }
java浅复制和深复制的区别
引用数据类型 - 赋值结果

对于引用数据类型,它们的内容其实是内存的地址。因此使用赋值操作符 =后, lPeoplerPeople指向同一块内存地址(即上图中的 @f7a53fd),通过该地址我们可以访问到它存储的对象。

所以,当我们通过rPeople来改变成员变量age的值之后,通过lPeople访问该成员变量可以看到更新后的值,这就是 基本数据类型和引用数据类型赋值的区别

2.3 浅拷贝

浅拷贝的前提是该类了实现Cloneable接口,并重写clone方法。在拷贝某个对象时,调用该对象的clone方法返回一个新的对象,该对象就是浅拷贝的结果。

    public static void startRun3() {
        People lPeople = new People();
        lPeople.age = 10;
        lPeople.holder = new People.Holder();
        lPeople.holder.holderValue = 10;
        People rPeople = (People) lPeople.clone();
        rPeople.age = 20;
        rPeople.holder.holderValue = 20;
        Log.d("CopySample", "lPeople=" + lPeople + ",lPeople.age=" + lPeople.age + ",lPeople.holder=" + lPeople.holder + ",\n" +
                "rPeople=" + rPeople + ",rPeople.age=" + rPeople.age + ",rPeople.holder=" + rPeople.holder);
        Log.d("CopySample", "lHolderValue=" + lPeople.holder.holderValue + ",rHolderValue=" + rPeople.holder.holderValue);
    }

    public static class People implements Cloneable {

        int age;
        Holder holder;

        @Override
        protected Object clone() {
            try {
                return super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }

        public static class Holder {
            int holderValue;
        }
    }
java浅复制和深复制的区别
浅拷贝

从上面的代码当中,我们可以看到,浅拷贝与赋值的区别在于:浅拷贝会为拷贝的对象 开辟一块新的内存空间(被拷贝的对象在 @f7a53fd,拷贝的对象在 @3a8bb43),但是这并不意味着这两者之间一定是完全独立的,因为 clone方法的默认实现,对类中不同类型的成员变量会有不同的表现。
  • 基本数据类型:对该成员变量进行复制。
  • 引用数据类型:复制引用,但不会开辟新的内存空间,因此被拷贝对象的该成员变量与拷贝对象对应的成员变量 指向同一块内存地址(上图中的@f5b08f2),就和我们在2.2.2中看到的一样。

正是由于这一区别,当我们通过rPeople对其成员变量进行修改时,lPeopleage属性(基本数据类型)不受影响,而holder.holderValue(引用数据类型)却会跟着改变。

2.4 深拷贝

下面,我们先来演示如何对2.2中的例子进行改进,实现深拷贝。我们让Holder类也实现了Clonable接口,因此调用它的clone方法后会返回一个新对象的引用;之后,还要重写Peopleclone方法,对clone之后的对象中的成员变量holder采用clone方法进行拷贝。

   public static void startRun3() {
        People lPeople = new People();
        lPeople.age = 10;
        lPeople.holder = new People.Holder();
        lPeople.holder.holderValue = 10;
        People rPeople = (People) lPeople.clone();
        rPeople.age = 20;
        rPeople.holder.holderValue = 20;
        Log.d("CopySample", "lPeople=" + lPeople + ",lPeople.age=" + lPeople.age + ",lPeople.holder=" + lPeople.holder + ",\n" +
                "rPeople=" + rPeople + ",rPeople.age=" + rPeople.age + ",rPeople.holder=" + rPeople.holder);
        Log.d("CopySample", "lHolderValue=" + lPeople.holder.holderValue + ",rHolderValue=" + rPeople.holder.holderValue);
    }

    public static class People implements Cloneable {

        int age;
        Holder holder;

        @Override
        protected Object clone() {
            try {
                People people = (People) super.clone();
                people.holder = (People.Holder) this.holder.clone();
                return people;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }

        public static class Holder implements Cloneable {

            int holderValue;

            @Override
            protected Object clone() {
                try {
                    return super.clone();
                } catch (CloneNotSupportedException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }
    }
java浅复制和深复制的区别
深拷贝

从打印的结果可以看到 rPeopleholder引用指向了一块新的内存地址 @b855c0,因此对它的 holderValue进行改变并不会影响到 lPeopleholder变量中的 holderValue

三、数组 & 集合的拷贝

3.1 数组的拷贝

数组除了默认实现了clone()方法之外,还提供了Arrays.copyOf方法用于拷贝,这两者都是浅拷贝。

3.1.1 基本数据类型数组

    public static void startRun4() {
        int[] lNumbers1 = new int[5];
        int[] rNumbers1 = lNumbers1;
        rNumbers1[0] = 1;
        Log.d("CopySample", "lNumbers1[0]=" + lNumbers1[0] + ",rNumbers1[0]=" + rNumbers1[0]);

        int[] lNumbers2 = new int[5];
        int[] rNumbers2 = Arrays.copyOf(lNumbers2, lNumbers2.length);
        rNumbers2[0] = 1;
        Log.d("CopySample", "lNumbers2[0]=" + lNumbers2[0] + ",rNumbers2[0]=" + rNumbers2[0]);

        int[] lNumbers3 = new int[5];
        int[] rNumbers3 = lNumbers3.clone();
        rNumbers3[0] = 1;
        Log.d("CopySample", "lNumbers3[0]=" + lNumbers3[0] + ",rNumbers3[0]=" + rNumbers3[0]);
    }

运行结果:


java浅复制和深复制的区别
基本数据类型数组

3.1.2 引用数据类型数组

    public static void startRun5() {
        People[] lNumbers1 = new People[5];
        lNumbers1[0] = new People();
        People[] rNumbers1 = lNumbers1;
        Log.d("CopySample", "lNumbers1[0]=" + lNumbers1[0] + ",rNumbers1[0]=" + rNumbers1[0]);

        People[] lNumbers2 = new People[5];
        lNumbers2[0] = new People();
        People[] rNumbers2 = Arrays.copyOf(lNumbers2, lNumbers2.length);
        Log.d("CopySample", "lNumbers2[0]=" + lNumbers2[0] + ",rNumbers2[0]=" + rNumbers2[0]);

        People[] lNumbers3 = new People[5];
        lNumbers3[0] = new People();
        People[] rNumbers3 = lNumbers3.clone();
        Log.d("CopySample", "lNumbers3[0]=" + lNumbers3[0] + ",rNumbers3[0]=" + rNumbers3[0]);
    }

    public static class People implements Cloneable {

        int age;
        Holder holder;

        @Override
        protected Object clone() {
            try {
                return super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }

        public static class Holder {
            int holderValue;
        }
    }
java浅复制和深复制的区别
引用数据类型数组

3.2 集合的拷贝

集合的拷贝也是我们平时经常会遇到的,一般情况下,我们都是用浅拷贝来实现,即通过构造函数或者clone方法。

3.2.1 构造函数和 clone() 默认都是浅拷贝

    public static void listShallowRun() {
        ArrayList<People> lPeoples = new ArrayList<>();
        People people1 = new People();
        lPeoples.add(people1);
        Log.d("CopySample", "listShallowRun, lPeoples[0]=" + lPeoples.get(0));
        ArrayList<People> rPeoples = (ArrayList<People>) lPeoples.clone();
        Log.d("CopySample", "listShallowRun, rPeoples[0]=" + rPeoples.get(0));
    }

    public static class People implements Cloneable {

        int age;
        Holder holder;

        @Override
        protected Object clone() {
            try {
                People people = (People) super.clone();
                people.holder = (People.Holder) this.holder.clone();
                return people;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }

        public static class Holder implements Cloneable {

            int holderValue;

            @Override
            protected Object clone() {
                try {
                    return super.clone();
                } catch (CloneNotSupportedException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }
    }
java浅复制和深复制的区别
集合的浅拷贝

3.2.2 实现集合的深拷贝

在某些特殊情况下,如果需要实现集合的深拷贝,那就要创建一个新的集合,然后通过深拷贝原先集合中的每个元素,将这些元素加入到新的集合当中。

   public static void listDeepRun() {
        ArrayList<People> lPeoples = new ArrayList<>();
        People people1 = new People();
        people1.holder = new People.Holder();
        lPeoples.add(people1);
        Log.d("CopySample", "listShallowRun, lPeoples[0]=" + lPeoples.get(0));
        ArrayList<People> rPeoples = new ArrayList<>();
        for (People people : lPeoples) {
            rPeoples.add((People) people.clone());
        }
        Log.d("CopySample", "listShallowRun, rPeoples[0]=" + rPeoples.get(0));
    }

    public static class People implements Cloneable {

        int age;
        Holder holder;

        @Override
        protected Object clone() {
            try {
                People people = (People) super.clone();
                people.holder = (People.Holder) this.holder.clone();
                return people;
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return null;
        }

        public static class Holder implements Cloneable {

            int holderValue;

            @Override
            protected Object clone() {
                try {
                    return super.clone();
                } catch (CloneNotSupportedException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }
    }