Java技术栈.基础篇—浅拷贝与深拷贝

秒速五厘米 2022-03-27 13:20 184阅读 0赞

## 浅拷贝与深拷贝是什么 ##

浅拷贝和深拷贝本质都是对一个已有**引用对象**进行拷贝操作，但二者存在一定的区别。

在 Java 中，数据类型分为 **基本数据类型**（元类型）和 **引用数据类型**。而一般使用 『 = 』号做赋值操作的时候，对于基本数据类型，实际上是拷贝的它的值，但是对于引用数据类型而言，其实将原对象的引用传递过去，它们实际是指向同一个对象。

而**浅拷贝和深拷贝的区别**就在于：在拷贝某个对象的时候，如果只对基本数据类型的成员变量进行了值的拷贝，而对引用数据类型的成员变量只是进行了引用的传递，而没有为其创建一个新的对象，是**浅拷贝**；反之，在对引用数据类型的成员变量进行拷贝的时候，为其创建了一个新的对象，并且复制其内的成员变量，则认为是**深拷贝**。

所以浅拷贝和深拷贝的本质是 对某个对象的引用数据类型的成员变量的不同操作而已。

### 浅拷贝 ###

对基本数据类型进行值传递，对引用数据类型进行引用传递的拷贝。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9taW5nZGV0aWFueGlh_size_16_color_FFFFFF_t_70]

### 深拷贝 ###

对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9taW5nZGV0aWFueGlh_size_16_color_FFFFFF_t_70 1]

## Java中的clone方法 ##

在 Java 中，所有的类都继承自 Object 。在 Object 中有一个 clone() 方法，浅拷贝和深拷贝 需要实现 clone() 方法，来完成操作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9taW5nZGV0aWFueGlh_size_16_color_FFFFFF_t_70 2]

通过注释我们知道所有调用 clone() 方法的对象，都必须实现 Cloneable 接口，否则将抛 CloneNotSupportedException 异常。

## 浅拷贝示例 ##

private class BoyObject implements Cloneable{
            public String name;
            public int age;
            public GirlFriend girlFriend;
    
            @Override
            public Object clone(){
                try {
                    return super.clone();
                } catch (CloneNotSupportedException e) {
                    System.out.println(e);
                }
                return null;
            }
    
    
        }
    
        private class GirlFriend implements Cloneable{
            public String name;
            public int age;
    
            @Override
            public Object clone(){
                try {
                    return super.clone();
                } catch (CloneNotSupportedException e) {
                    System.out.println(e);
                }
                return null;
            }
        }
    
        public void cloneTest() {
            BoyObject boyObject = new BoyObject();
            boyObject.girlFriend = new GirlFriend();
            boyObject.name = "xiaoqiang";
            boyObject.age = 18;
            boyObject.girlFriend.name = "xiaoli";
            boyObject.girlFriend.age = 18;
    
            BoyObject cloneObject = (BoyObject)boyObject.clone();
    
            System.out.println("boyObject hashcode=" + boyObject.hashCode());
            System.out.println("boyObject name=" + boyObject.name);
            System.out.println("boyObject age=" + boyObject.age);
            System.out.println("boyObject girlFriend hashcode=" + boyObject.girlFriend.hashCode());
    
            System.out.println("cloneObject hashcode=" + cloneObject.hashCode());
            System.out.println("cloneObject name=" + cloneObject.name);
            System.out.println("cloneObject age=" + cloneObject.age);
            System.out.println("cloneObject girlFriend hashcode=" + cloneObject.girlFriend.hashCode());
        }

运行测试方法，输出如下：

boyObject hashcode=935044096
    boyObject name=xiaoqiang
    boyObject age=18
    boyObject girlFriend hashcode=396180261
    
    cloneObject hashcode=625576447
    cloneObject name=xiaoqiang
    cloneObject age=18
    cloneObject girlFriend hashcode=396180261

由上可知，boyObject 与 cloneObject 的hashcode不同，说明 由boyObject.clone() 得到了一个新的 BoyObject 对象。但这是一次浅拷贝，因为 boyObject.girlFriend .hashcode 与 cloneObject.girlFriend.hashcode 一致，说明在boyObject 拷贝时girlFriend 只是进行了应用传递，而没有创建一个新的 GirlFriend 对象。boyObject 与 cloneObject 的 girlFriend 属性指向同一个对象。

## 深拷贝实例 ##

深拷贝只做以下改动，其他保持不变：

private class BoyObject implements Cloneable{
            public String name;
            public int age;
            public GirlFriend girlFriend;
    
            @Override
            public Object clone(){
                try {
                    BoyObject cloneObject = (BoyObject)super.clone();
                    cloneObject.girlFriend = (GirlFriend)this.girlFriend.clone();
                    return cloneObject;
                } catch (CloneNotSupportedException e) {
                    System.out.println(e);
                }
                return null;
            }
        }

重新运行后输出如下：

由上可知，boyObject.girlFriend .hashcode 与 cloneObject.girlFriend.hashcode 不一致，说明boyObject.clone()方法在拷贝时创建了一个新的 GirlFriend 对象赋值给了cloneObject的 girlFriend属性，是深拷贝。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9taW5nZGV0aWFueGlh_size_16_color_FFFFFF_t_70]: /images/20220327/feada636421a4bc781b05c55a83d3662.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9taW5nZGV0aWFueGlh_size_16_color_FFFFFF_t_70 1]: /images/20220327/54941398ddc24245bb3bb96b42fdab42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpYW9taW5nZGV0aWFueGlh_size_16_color_FFFFFF_t_70 2]: /images/20220327/de09446e3232449193439e1d1e0d0595.png