1、深拷贝与浅拷贝-20220823

最新推荐文章于 2024-08-12 15:45:48 发布

Vialaner

最新推荐文章于 2024-08-12 15:45:48 发布

阅读量166

点赞数

分类专栏： Master的星期一文章标签： java spring jvm

本文链接：https://blog.csdn.net/u011922236/article/details/126491141

版权

Master的星期一专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

前言
一、对象拷贝是什么？
二、分类
三、补充
- 3.1、Object类中的clone()方法属于浅拷贝。
- 3.2、java.lang.Cloneable接口
四、调用clone方法抛出异常案例演示
五、证明Object类中的clone是浅拷贝
六、如何实现深拷贝
七、总结

前言

本文主要是作者针对对象拷贝这一问题做的总结，仅供个人学习使用。
提示：以下是本篇文章正文内容，下面案例可供参考

一、对象拷贝是什么？

对象拷贝（Object Copy）是将一个对象的属性拷贝到另一个有着相同类型的对象中去。
在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用对象的部分或者全部属性值。

二、分类

对象拷贝分为浅拷贝（Shallow Copy）和深拷贝(Deep Copy)两种。下面逐一解释说明。

2.1、浅拷贝

2.1.1、简述

浅拷贝是按位拷贝对象，会创建一个新对象，这个对象有着原始对象属性的一份精确拷贝。

2.1.2、说明

对于基本类型的引用，浅拷贝就是只拷贝基本类型的值。
对于引用类型来说，浅拷贝拷贝的是内存地址。因此如果其中一个对象改变了这个地址，就会影响到另一个对象。
总结一句话就是：两个引用指向同一个对象就是浅拷贝。

2.2、深拷贝

2.2.1、简述

深拷贝是指拷贝了源对象的所有值。所以即使源对象的属性值发生变化时，拷贝对象的值不会发生改变。
深拷贝会拷贝所有的属性，并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝是即发生深拷贝。
深拷贝相对于浅拷贝速度较慢并且花销较大。

2.3、图示深浅拷贝

在这里插入图片描述

三、补充

3.1、Object类中的clone()方法属于浅拷贝。

在这里插入图片描述

3.2、java.lang.Cloneable接口

在这里插入图片描述

四、调用clone方法抛出异常案例演示

4.1、定义Boss类，实现Cloneable接口

package com.zzkk.design.clone;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Boss implements Cloneable
{
    private String bossName;
    private String title;
}

4.2、定义ShallowCopyDemo类

package com.zzkk.design.clone;

public class ShallowCopyDemo
{
    public static void main(String[] args) throws CloneNotSupportedException
    {
		copyTest01();
    }

    private static void copyTest01() throws CloneNotSupportedException
    {
        ShallowCopyDemo shallowCopyDemo = new ShallowCopyDemo();

        Object clone = shallowCopyDemo.clone();
    }
}

4.3、结果报错

Exception in thread "main" java.lang.CloneNotSupportedException: com.zzkk.design.clone.ShallowDeepCopyDemo
	at java.base/java.lang.Object.clone(Native Method)
	at com.zzkk.design.clone.ShallowDeepCopyDemo.copyTest01(ShallowDeepCopyDemo.java:26)
	at com.zzkk.design.clone.ShallowDeepCopyDemo.main(ShallowDeepCopyDemo.java:19)

4.4、原因分析

在调用clone()方法的时候，调用者如果没有实现Cloneable接口，会报错如上错误CloneNotSupportedException。也就是ShallowDeepCopyDemo这个类要实现Cloneable接口。

4.4.1、正确使用

package com.zzkk.design.clone;

public class ShallowCopyDemo implements Cloneable {
    public static void main(String[] args) throws CloneNotSupportedException{
		copyTest01();
    }

    private static void copyTest01() throws CloneNotSupportedException{
        ShallowCopyDemo shallowCopyDemo = new ShallowCopyDemo();
        Object clone = shallowCopyDemo.clone();
    }
}

4.5、结论

如果某个类没有实现Cloneable接口，直接调用clone方法，会抛出异常CloneNotSupportedException。

五、证明Object类中的clone是浅拷贝

5.1、在Boss类中实现clone方法

package com.zzkk.design.clone;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Boss implements Cloneable
{
    private String bossName;
    private String title;
    
    @Override
    protected Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
}

5.2、定义Emp类，实现Cloneable接口

package com.zzkk.design.clone;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.*;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Emp implements Cloneable
{
    private String empName;
    private Integer age;
    private Boss boss;

    public Emp(String empName, Integer age,String bossName,String title)
    {
        this.empName = empName;
        this.age = age;
        this.boss = new Boss(bossName,title);
    }

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

5.3、在ShallowCopyDemo类中测试

5.3.1、代码演示

public static void main(String[] args) throws CloneNotSupportedException
    {
        Emp emp = new Emp("铁牛",15,"马云","CEO");
        System.out.println("---原始对象:"+emp.getBoss().getTitle());

        Emp emp2 = (Emp)emp.clone();
        System.out.println("---拷贝对象:"+emp2.getBoss().getTitle());

        System.out.println("========只对拷贝对象emp2修改");
        emp2.getBoss().setTitle("PM2");
        System.out.println("----修改之后");

        System.out.println("---原始对象:"+emp.getBoss().getTitle());
        System.out.println("---拷贝对象:"+emp2.getBoss().getTitle());
    }

5.3.2、运行结果

---原始对象:CEO
---拷贝对象:CEO
========只对拷贝对象emp2修改
----修改之后
---原始对象:PM2
---拷贝对象:PM2

5.3.3、结论

emp调用clone方法之后，原始对象和拷贝对象中引用类型Boss的属性title值是相同的CEO；修改emp2的属性Boss的title属性值为PM2后，emp没有修改，打印原始对象和拷贝对象的title值，发现都是PM2。
得出结论，Object类中的clone方法是浅拷贝。多个引用指向同一个对象，任何一个修改都会影响对应的引用。

六、如何实现深拷贝

6.1、方式一：重写Clone方法

6.1.1、重新定义Boss、Emp类

package com.zzkk.design.clone.deep;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Boss implements Cloneable
{
    private String bossName;
    private String title;
    
    @Override
    protected Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
}

package com.zzkk.design.clone.deep;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Emp implements Cloneable
{
    private String empName;
    private Integer age;
    private Boss boss;
    
    public Emp(String empName, Integer age,String bossName,String title)
    {
        this.empName = empName;
        this.age = age;
        this.boss = new Boss(bossName,title);
    }
    
    //2 深拷贝
    @Override
    protected Object clone() throws CloneNotSupportedException
    {
        return new Emp(empName,age,boss.getBossName(),boss.getTitle());
    }
}

6.1.2、定义DeepCopyDemo类

package com.zzkk.design.clone.deep;

public class DeepCopyDemo
{
    public static void main(String[] args) throws CloneNotSupportedException
    {
        Emp emp = new Emp("铁牛",15,"马云","CEO");
        System.out.println("---原始对象:"+emp.getBoss().getTitle());

        Emp emp2 = (Emp)emp.clone();
        System.out.println("---拷贝对象:"+emp2.getBoss().getTitle());

        System.out.println("========只对拷贝对象emp2修改");
        emp2.getBoss().setTitle("PM2");
        System.out.println("----修改之后");

        System.out.println("---原始对象:"+emp.getBoss().getTitle());
        System.out.println("---拷贝对象:"+emp2.getBoss().getTitle());
    }
    
}

6.1.3、运行结果

---原始对象:CEO
---拷贝对象:CEO
========只对拷贝对象emp2修改
----修改之后
---原始对象:CEO
---拷贝对象:PM2

6.1.4、结论

emp调用clone方法之后，原始对象和拷贝对象中引用类型Boss的属性title值是相同的CEO；修改emp2的属性Boss的title属性值为PM2后，emp没有修改，打印原始对象和拷贝对象的title值，发现emp的Boss的title值是CEO，而emp2的Boss的title值是PM2，两者不一样。
得出结论，重写clone方法是可以实现深拷贝的方式之一。

6.1.5、问题点

重写clone方法虽然能实现深拷贝，但是因为存在new对象的问题，不够友好，性能多少都有些欠缺，虽然影响不大。但作为程序员，应该尽可能的让程序优雅，高效。所以我们引出第二种实现深拷贝的方式。

6.2、方式二：实现Serializable接口

6.2.1、重新定义Boss类，实现Serializable接口

package com.zzkk.design.clone.deep2;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Boss implements Serializable
{
    private String bossName;
    private String title;
    
}

6.2.2、重新定义Emp类，实现Serializable接口，自定义clone方法

package com.zzkk.design.clone.deep2;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.*;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Emp implements Serializable
{
    private String empName;
    private Integer age;
    private Boss boss;
    
    public Emp(String empName, Integer age,String bossName,String title)
    {
        this.empName = empName;
        this.age = age;
        this.boss = new Boss(bossName,title);
    }

    //深拷贝实现方式2：实现Serializable接口，自定义clone方法
    public Emp clone()
    {
        Emp result = null;
        
        try
        {
            //将当前Jvm虚拟机的对象this，使用输出流写到内存中。this指的是当前对象，也就是谁调用这个clone方法，谁就是当前对象。
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(this);
            //使用输入流将上一步写到内存中的数据读出来，序列化为一个新的对象
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            result = (Emp)objectInputStream.readObject();
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

}

6.2.3、自定义Deep2CopyDemo测试类

package com.zzkk.design.clone.deep2;

public class Deep2CopyDemo
{
    public static void main(String[] args) throws CloneNotSupportedException
    {
        Emp emp = new Emp("铁牛",15,"马云","CEO");
        System.out.println("---原始对象:"+emp.getBoss().getTitle());

        Emp emp2 = (Emp)emp.clone();
        System.out.println("---拷贝对象:"+emp2.getBoss().getTitle());

        System.out.println("========只对拷贝对象emp2修改");
        emp2.getBoss().setTitle("CTO");
        System.out.println("----修改之后");

        System.out.println("---原始对象:"+emp.getBoss().getTitle());
        System.out.println("---拷贝对象:"+emp2.getBoss().getTitle());
    }
    
}

6.2.4、运行结果

---原始对象:CEO
---拷贝对象:CEO
========只对拷贝对象emp2修改
----修改之后
---原始对象:CEO
---拷贝对象:CTO

6.2.5、结论

以上就是通过实现序列化接口Serializable接口，自定义clone方法，通过字节数组输出流ByteArrayOutputStream和对象输出流ObjectOutputStream ，将JVM虚拟机中的数据写到内存中，然后再通过字节数组输入流ByteArrayInputStream和对象输入流ObjectInputStream 将内存中的数据读出来，序列化为一个新的对象。

6.2.6、注意点

在实际开发中，使用输入输出流对象，使用完后要记得关闭流。

七、总结

以上就是今天要讲的内容，本文仅仅简单介绍了深浅拷贝，而在实际使用开发过程中，以实际情况为准则。另外在实际开发过程中，我们使用的Spring的工具类BeanUtils.copyProperties(Object source, Object target)方法，对引用类型是浅拷贝。

PS：图文如有侵权，请联系作者删除。

欢迎大家点赞👍收藏💖评论💬关注🔒

Vialaner

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
1、深拷贝与浅拷贝-20220823

本文主要是作者针对对象拷贝这一问题做的总结，仅供个人学习使用。提示：以下是本篇文章正文内容，下面案例可供参考}} }} }} }} //2 深拷贝 @Override protected Object clone() throws CloneNotSupportedException {} }Emp emp = new Emp("铁牛" , 15 , "马云" , "CEO");
复制链接

扫一扫