5张图搞懂Java深浅拷贝

向右看齐 2022-12-28 15:30 188阅读 0赞

> 微信搜一搜 **「bigsai」** 关注这个专注于Java和数据结构与算法的铁铁  
> 文章收录在[github/bigsai-algorithm][github_bigsai-algorithm] 欢迎star收藏  
> 如果本篇对你有帮助，记得点赞收藏哦！

在开发、刷题、面试中，我们可能会遇到将一个对象的属性赋值到另一个对象的情况，这种情况就叫做拷贝。拷贝与Java内存结构息息相关，搞懂Java深浅拷贝是很必要的！

在对象的拷贝中，很多初学者可能搞不清到底是拷贝了引用还是拷贝了对象。在拷贝中这里就分为引用拷贝、浅拷贝、深拷贝进行讲述。

### 引用拷贝 ###

引用拷贝会生成一个新的对象引用地址，但是两个最终指向依然是同一个对象。如何更好的理解引用拷贝呢？很简单，就拿我们人来说，通常有个姓名，但是不同场合、人物对我们的叫法可能不同，但我们很清楚哪些名称都是属于"我"的！

![image-20201216222353944][]

当然，通过一个代码示例让大家领略一下(为了简便就不写get、set等方法)：

class Son {
        
        String name;
        int age;
    
        public Son(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    }
    public class test {
        
        public static void main(String[] args) {
        
            Son s1 = new Son("son1", 12);
            Son s2 = s1;
            s1.age = 22;
            System.out.println(s1);
            System.out.println(s2);
            System.out.println("s1的age:" + s1.age);
            System.out.println("s2的age:" + s2.age);
            System.out.println("s1==s2" + (s1 == s2));//相等
        }
    }

输出的结果为：

Son@135fbaa4
    Son@135fbaa4
    s1的age:22
    s2的age:22
    true

### 浅拷贝 ###

如何创建一个对象，将目标对象的内容复制过来而不是直接拷贝引用呢？

这里先讲一下**浅拷贝**，浅拷贝会创建一个新对象，新对象和原对象本身没有任何关系，**新对象和原对象不等，但是新对象的属性和老对象相同**。具体可以看如下区别：

*  如果属性是基本类型(int,double,long,boolean等)，拷贝的就是基本类型的值；
 *  如果属性是引用类型，拷贝的就是内存地址（即复制引用但不复制引用的对象） ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。

如果用一张图来描述一下浅拷贝，它应该是这样的：

![image-20201217002917565][]

如何实现浅拷贝呢？也很简单，**就是在需要拷贝的类上实现Cloneable接口并重写其clone()方法**。

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

在使用的时候直接调用类的clone()方法即可。具体案例如下：

class Father{
        
        String name;
        public Father(String name) {
        
            this.name=name;
        }
        @Override
        public String toString() {
        
            return "Father{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    class Son implements Cloneable {
        
        int age;
        String name;
        Father father;
        public Son(String name,int age) {
        
            this.age=age;
            this.name = name;
        }
        public Son(String name,int age, Father father) {
        
            this.age=age;
            this.name = name;
            this.father = father;
        }
        @Override
        public String toString() {
        
            return "Son{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    ", father=" + father +
                    '}';
        }
        @Override
        protected Son clone() throws CloneNotSupportedException {
        
            return (Son) super.clone();
        }
    }
    public class test {
        
        public static void main(String[] args) throws CloneNotSupportedException {
        
            Father f=new Father("bigFather");
            Son s1 = new Son("son1",13);
            s1.father=f;
            Son s2 = s1.clone();
            
            System.out.println(s1);
            System.out.println(s2);
            System.out.println("s1==s2:"+(s1 == s2));//不相等
            System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//相等
            System.out.println();
    
            //但是他们的Father father 和String name的引用一样
            s1.age=12;
            s1.father.name="smallFather";//s1.father引用未变
            s1.name="son222";//类似 s1.name=new String("son222") 引用发生变化
            System.out.println("s1.Father==s2.Father:"+(s1.father == s2.father));//相等
            System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//不相等
            System.out.println(s1);
            System.out.println(s2);
        }
    }

运行结果为：

Son{age=13, name='son1', father=Father{name='bigFather'}}
    Son{age=13, name='son1', father=Father{name='bigFather'}}
    s1==s2:false
    s1.name==s2.name:true//此时相等
    
    s1.Father==s2.Father:true
    s1.name==s2.name:false//修改引用后不等
    Son{age=12, name='son222', father=Father{name='smallFather'}}
    Son{age=13, name='son1', father=Father{name='smallFather'}}

不出意外，这种浅拷贝除了对象本身不同以外，各个零部件和关系和拷贝对象都是相同的，就好像双胞胎一样，是两个人，但是其开始的样貌、各种关系(父母亲人)都是相同的。**需要注意**的是其中name初始`==`是相等的，是因为初始浅拷贝它们指向一个相同的String，而后`s1.name="son222"` 则改变引用指向。

![image-20201217103648400][]

### 深拷贝 ###

对于上述的问题虽然拷贝的两个对象不同，但其内部的一些引用还是相同的，怎么样绝对的拷贝这个对象，使这个对象完全独立于原对象呢？就使用我们的深拷贝了。深拷贝：**在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量。**

![image-20201217111300466][]

在具体实现深拷贝上，这里提供两个方式，重写clone()方法和序列法。

##### 重写clone()方法 #####

如果使用重写clone()方法实现深拷贝，那么要将类中所有自定义引用变量的类也去实现Cloneable接口实现clone()方法。对于字符类可以创建一个新的字符串实现拷贝。

对于上述代码，Father类实现Cloneable接口并重写clone()方法。**son的clone()方法需要对各个引用都拷贝一遍**。

//Father clone()方法
    @Override
    protected Father clone() throws CloneNotSupportedException {
        
        return (Father) super.clone();
    }
    //Son clone()方法
    @Override
    protected Son clone() throws CloneNotSupportedException {
        
        Son son= (Son) super.clone();//待返回克隆的对象
        son.name=new String(name);
        son.father=father.clone();
        return son;
    }

其他代码不变，执行结果如下：

Son{age=13, name='son1', father=Father{name='bigFather'}}
    Son{age=13, name='son1', father=Father{name='bigFather'}}
    s1==s2:false
    s1.name==s2.name:false
    
    s1.Father==s2.Father:false
    s1.name==s2.name:false
    Son{age=12, name='son222', father=Father{name='smallFather'}}
    Son{age=13, name='son1', father=Father{name='bigFather'}}

##### 序列化 #####

可以发现这种方式实现了深拷贝。但是这种情况有个问题，如果引用数量或者层数太多了怎么办呢？

![image-20201217105458651][]

不可能去每个对象挨个写clone()吧？那怎么办呢？借助序列化啊。

因为序列化后：将二进制字节流内容写到一个媒介（文本或字节数组），然后是从这个媒介读取数据，原对象写入这个媒介后拷贝给clone对象，原对象的修改不会影响clone对象，因为clone对象是从这个媒介读取。

熟悉对象缓存的知道我们经常将Java对象缓存到Redis中，然后还可能从Redis中读取生成Java对象，这就用到序列化和反序列化。一般可以将Java对象存储为字节流或者json串然后反序列化成Java对象。因为序列化会储存对象的属性但是**不会也无法存储对象在内存中地址相关信息**。所以在反序列化成Java对象时候会重新创建所有的引用对象。

在具体实现上，自定义的类**需要实现Serializable接口**。在需要深拷贝的类(Son)中定义一个函数返回该类对象：

protected Son deepClone() throws IOException, ClassNotFoundException {
        
          Son son=null;
          //在内存中创建一个字节数组缓冲区，所有发送到输出流的数据保存在该字节数组中
          //默认创建一个大小为32的缓冲区
          ByteArrayOutputStream byOut=new ByteArrayOutputStream();
          //对象的序列化输出
          ObjectOutputStream outputStream=new ObjectOutputStream(byOut);//通过字节数组的方式进行传输
          outputStream.writeObject(this);  //将当前student对象写入字节数组中
    
          //在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区
          ByteArrayInputStream byIn=new ByteArrayInputStream(byOut.toByteArray()); //接收字节数组作为参数进行创建
          ObjectInputStream inputStream=new ObjectInputStream(byIn);
          son=(Son) inputStream.readObject(); //从字节数组中读取
          return  son;
    }

使用时候调用我们写的方法即可，其他不变，实现的效果为：

### 写在最后 ###

原创不易，bigsai我请你帮两件事帮忙一下:

1.  点赞支持一下， 您的肯定是我在csdn创作的源源动力。
2.  微信搜索「**bigsai**」，关注我的公众号(新人求支持)，不仅免费送你电子书，我还会第一时间在公众号分享知识技术。加我还可拉你进力扣打卡群一起打卡LeetCode。

记得关注、咱们下次再见！

![image-20201114211553660][]

[github_bigsai-algorithm]: https://github.com/javasmall/bigsai-algorithm
[image-20201216222353944]: /images/20221120/dc9e49c3cf2347bdb85922dcd504150c.png
[image-20201217002917565]: /images/20221120/3796ae42a93f41ea8232b3e63937b314.png
[image-20201217103648400]: /images/20221120/776a9b4055974368bcc87d26d5d211da.png
[image-20201217111300466]: /images/20221120/b68c12c2173d4499b1c36f547e0f89fe.png
[image-20201217105458651]: https://img-blog.csdnimg.cn/img_convert/095405676449ae450c0be0fae27107d3.png
[image-20201114211553660]: https://img-blog.csdnimg.cn/img_convert/3cd335655373276f330fa2c16b0e20f6.png