您当前的位置:首页 > 电脑百科 > 程序开发 > 编程百科

简单聊聊对象浅拷贝和深拷贝,真不简单!

时间:2023-05-17 15:08:57  来源:  作者:Java极客技术


一、摘要

上篇文章中,我们有介绍到对象属性复制相关的工具,这些工具所进行的对象拷贝,其实都是浅拷贝模式。

可能有的同学会发出疑问,什么叫浅拷贝?

我们都知道,JAVA 中的数据类型分为值类型(基本数据类型)和引用类型,值类型包括 byte、short、 int、long、float、double、boolean、char 等简单数据类型,引用类型包括类、接口、数组等复杂类型。

根据数据类型的不同,在进行属性值拷贝的时候,如果是值类型,复制的是属性值,如果是复杂类型,比如对象,复制的内容可能是属性对应的内存引用地址。

因此,在 Java 中对于复杂类型的数据,也分为**浅拷贝(浅克隆)与深拷贝(深克隆)**方式,区别如下:

  • 浅拷贝:将原对象或原数组的引用直接赋给新对象或者新数组,新对象只是原对象的一个引用,也就是说不管新对象还是原对象,都是引用同一个对象
  • 深拷贝:创建一个新的对象或者数组,将原对象的各项属性的值拷贝过来,是“值”而不是“引用”,两者对象是不一样的

对于概念的解释,可能也很难理解,下面我们简单的通过几个案例向大家介绍!

二、案例实践

2.1、浅拷贝

首先我们新建两个对象,其中User关联Account对象,内容如下:

public class User {

    /**
     * 用户ID
     */
    private Long userId;

    /**
     * 账户信息
     */
    private Account account;

    //...get、set

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", account=" + account +
                '}';
    }
}
 
public class Account {

    /**
     * 账号余额
     */
    private BigDecimal money;

    //...get、set

    @Override
    public String toString() {
        return "Account{" +
                "money=" + money +
                '}';
    }
}

使用Spring BeanUtils工具进行对象属性复制,操作如下:

// 定义某用户,账户余额 100块
Account sourceAccount = new Account();
sourceAccount.setMoney(BigDecimal.valueOf(100));

User sourceUser = new User();
sourceUser.setUserId(1L);
sourceUser.setAccount(sourceAccount);

// 进行对象属性拷贝
User targetUser = new User();
BeanUtils.copyProperties(sourceUser, targetUser);
System.out.println("修改嵌套对象属性值前的结果:" + targetUser.toString());

//修改原始对象账户余额为200
sourceAccount.setMoney(BigDecimal.valueOf(200));

System.out.println("修改嵌套对象属性值后的结果:" + targetUser.toString());

输出结果如下:

修改嵌套对象属性值前的结果:User{userId=1, account=Account{money=100}}
修改嵌套对象属性值后的结果:User{userId=1, account=Account{money=200}}

从结果上可以很明显的得出结论:当修改原始的嵌套对象Account的属性值时,目标对象的Account对象对应的值也跟着发生变化。

很显然,这与我们预期想要的对象属性拷贝是想违背的,我们所期待的结果是:原始对象值即使发生变化,目标对象的值也不应该发生变化!

面对这种情况,怎么处理呢?

我们可以把对象Account单独拉出来,进行一次属性值拷贝,然后再进行封装,比如操作如下:

// 定义某用户,账户余额 100块
Account sourceAccount = new Account();
sourceAccount.setMoney(BigDecimal.valueOf(100));

User sourceUser = new User();
sourceUser.setUserId(1L);
sourceUser.setAccount(sourceAccount);


// 拷贝 Account 对象
Account targetAccount = new Account();
BeanUtils.copyProperties(sourceAccount, targetAccount);

// 拷贝 User 对象
User targetUser = new User();
BeanUtils.copyProperties(sourceUser, targetUser);
targetUser.setAccount(targetAccount);
System.out.println("修改嵌套对象属性值前的结果:" + targetUser.toString());

//修改原始对象账户余额为200
sourceAccount.setMoney(BigDecimal.valueOf(200));

System.out.println("修改嵌套对象属性值后的结果:" + targetUser.toString());

输出结果如下:

修改嵌套对象属性值前的结果:User{userId=1, account=Account{money=100}}
修改嵌套对象属性值后的结果:User{userId=1, account=Account{money=100}}

即使Account对象数据发生变化,也不会改目标对象的数据,与预期结果一致!

现在的情况是User只有一个嵌套对象Account,假如像这样的对象有十几个呢,采用以上方式显然不可取。

这个时候深拷贝,该登场了!

2.2、深拷贝

Java 的深拷贝有两种实现方式,第一种是通过将对象序列化到临时文件,然后再通过反序列化方式,从临时文件中读取数据,操作案例如下!

首先所有的类,必须实现Serializable接口,推荐显式定义序列化 ID。

public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 用户ID
     */
    private Long userId;

    /**
     * 账户信息
     */
    private Account account;

    //...get、set

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", account=" + account +
                '}';
    }
}
 
public class Account implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 账号余额
     */
    private BigDecimal money;

    //...get、set

    @Override
    public String toString() {
        return "Account{" +
                "money=" + money +
                '}';
    }
}

// 定义某用户,账户余额 100块
Account sourceAccount = new Account();
sourceAccount.setMoney(BigDecimal.valueOf(100));

User sourceUser = new User();
sourceUser.setUserId(1L);
sourceUser.setAccount(sourceAccount);


//把对象写入文件中
try {
    FileOutputStream fos = new FileOutputStream("temp.out");
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(sourceUser);
    oos.flush();
    oos.close();
} catch (IOException e) {
    e.printStackTrace();
}

//从文件中读取对象
User targetUser = null;
try {
    FileInputStream fis = new FileInputStream("temp.out");
    ObjectInputStream ois = new ObjectInputStream(fis);
    targetUser = (User) ois.readObject();
    fis.close();
    ois.close();
}  catch (Exception e) {
    e.printStackTrace();
}

System.out.println("修改嵌套对象属性值前的结果:" + targetUser.toString());

//修改原始对象账户余额为200
sourceAccount.setMoney(BigDecimal.valueOf(200));

System.out.println("修改嵌套对象属性值后的结果:" + targetUser.toString());

输出结果:

修改嵌套对象属性值前的结果:User{userId=1, account=Account{money=100}}
修改嵌套对象属性值后的结果:User{userId=1, account=Account{money=100}}

通过序列化和反序列化的方式,可以实现多层复杂的对象数据拷贝。

因为涉及到需要将数据写入临时磁盘,性能可能会有所下降!

2.3、json 序列化和反序列化

对于对象深度拷贝,还有第二种方式,那就是采用 json 序列化和反序列化相关的技术来实现,同时性能也比将数据写入临时磁盘的方式要好很多,并且不需要显式实现序列化接口。

json 序列化和反序列化的底层思想是,将对象序列化成字符串;然后再将字符串通过反序列化方式成对象。

以jackson工具库为例,具体使用方式如下!

首先导入相关的jackson依赖包!

<!--jackson依赖-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.8</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.8</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>

其次,编写统一Json处理工具类!

public class JsonUtil {

    private static final Logger log = LoggerFactory.getLogger(JsonUtil.class);

    private static ObjectMApper objectMapper = new ObjectMapper();

    static {
        // 序列化时,将对象的所有字段全部列入
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        // 允许没有引号的字段名
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        // 自动给字段名加上引号
        objectMapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, true);
        // 时间默认以时间戳格式写,默认时间戳
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
        // 忽略空bean转json的错误
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        // 设置时间转换所使用的默认时区
        objectMapper.setTimeZone(TimeZone.getDefault());


        // 反序列化时,忽略在json字符串中存在, 但在java对象中不存在对应属性的情况, 防止错误
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);

        //序列化/反序列化,自定义设置
        SimpleModule module = new SimpleModule();
        // 序列化成json时,将所有的long变成string
        module.addSerializer(Long.class, ToStringSerializer.instance);
        module.addSerializer(Long.TYPE, ToStringSerializer.instance);
        // 自定义参数配置注册
        objectMapper.registerModule(module);
    }

    /**
     * 对象序列化成字符串
     * @param obj
     * @param <T>
     * @return
     */
    public static <T> String objToStr(T obj) {
        if (null == obj) {
            return null;
        }

        try {
            return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
        } catch (Exception e) {
            log.warn("objToStr error: ", e);
            return null;
        }
    }

    /**
     * 字符串反序列化成对象
     * @param str
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T strToObj(String str, Class<T> clazz) {
        try {
            return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
        } catch (Exception e) {
            log.warn("strToObj error: ", e);
            return null;
        }
    }

    /**
     * 字符串反序列化成对象(数组)
     * @param str
     * @param typeReference
     * @param <T>
     * @return
     */
    public static <T> T strToObj(String str, TypeReference<T> typeReference) {
        try {
            return (T) (typeReference.getType().equals(String.class) ? str : objectMapper.readValue(str, typeReference));
        } catch (Exception e) {
            log.warn("strToObj error", e);
            return null;
        }
    }
}

最后,在相关的位置引入即可。

// 定义某用户,账户余额 100块
Account sourceAccount = new Account();
sourceAccount.setMoney(BigDecimal.valueOf(100));

User sourceUser = new User();
sourceUser.setUserId(1L);
sourceUser.setAccount(sourceAccount);

// json序列化、反序列化
User targetUser = JsonUtil.strToObj(JsonUtil.objToStr(sourceUser), User.class);
System.out.println("修改嵌套对象属性值前的结果:" + targetUser.toString());

//修改原始对象账户余额为200
sourceAccount.setMoney(BigDecimal.valueOf(200));

System.out.println("修改嵌套对象属性值后的结果:" + targetUser.toString());

输出结果:

修改嵌套对象属性值前的结果:User{userId=1, account=Account{money=100}}
修改嵌套对象属性值后的结果:User{userId=1, account=Account{money=100}}

与预期一致!

三、小结

本文主要围绕对象的浅拷贝和深拷贝,从使用方面做了一次简单的内容总结。

浅拷贝下,原对象和目标对象,引用都是同一个对象,当被引用的对象数据发生变化时,相关的引用者也会跟着一起变。

深拷贝下,原对象和目标对象数据是两个完全独立的存在,相互直接不受影响。

至于当前对象数据,是应该走浅拷贝还是深拷贝模式好,完全取决于当前业务的需求,没有绝对的好或者不好!

如果当前对象需要深拷贝,推荐采用 json 序列化和反序列化的方式实现,相比通过文件写入的方式进行序列化和反序列化,操作简单且性能高!



Tags:浅拷贝   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,不构成投资建议。投资者据此操作,风险自担。如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除。
▌相关推荐
一、摘要上篇文章中,我们有介绍到对象属性复制相关的工具,这些工具所进行的对象拷贝,其实都是浅拷贝模式。可能有的同学会发出疑问,什么叫浅拷贝?我们都知道,Java 中的数据类型分...【详细内容】
2023-05-17  Tags: 浅拷贝  点击:(0)  评论:(0)  加入收藏
最近有一位00后的小妹妹粉丝私信小编说自己很喜欢编程,目前在某公司实习前端开发工作,说到现在为止还没有搞懂JavaScript中深拷贝和浅拷贝这个问题,同时也在网上看了很多关于深...【详细内容】
2023-05-12  Tags: 浅拷贝  点击:(13)  评论:(0)  加入收藏
Java中的对象复制主要有三种方式:clone、深拷贝和浅拷贝。这些技术对于Java开发人员来说非常重要,因为它们可以帮助开发人员管理复杂的数据结构。本文将详细讨论这三种技术,...【详细内容】
2023-05-06  Tags: 浅拷贝  点击:(20)  评论:(0)  加入收藏
为了让读者更好的理解深浅拷贝,在讲深浅拷贝之前要引入基本数据类型 , 引用数据类型 和 数据储存(栈和堆)这几个概念,如果已经理解,可直接跳过这一part。JS数据类型Q:前端面试常...【详细内容】
2019-09-03  Tags: 浅拷贝  点击:(404)  评论:(0)  加入收藏
假设你去面试 Python 开发岗,面试官如果对基础比较看重的话,那么很可能会问你这样的问题“谈谈你对 Python 中的浅拷贝和深拷贝的理解?”若平时你在开发中像我一样,过度使用 dee...【详细内容】
2019-09-03  Tags: 浅拷贝  点击:(390)  评论:(0)  加入收藏
对于各种编程语言,深浅拷贝总可以让初学者头疼不已。而Python--这门十分受欢迎的语言也不例外。下面,分享下自己对Python深浅拷贝的理解。 浅复制后,两个变量同时变化 深复制后...【详细内容】
2019-08-15  Tags: 浅拷贝  点击:(477)  评论:(0)  加入收藏
▌简易百科推荐
一、摘要上篇文章中,我们有介绍到对象属性复制相关的工具,这些工具所进行的对象拷贝,其实都是浅拷贝模式。可能有的同学会发出疑问,什么叫浅拷贝?我们都知道,Java 中的数据类型分...【详细内容】
2023-05-17  Java极客技术    Tags:浅拷贝   点击:(0)  评论:(0)  加入收藏
我们都知道,磁盘IO以块为单位读取数据,如果你所需要的数据都存储在一个块呢,一次IO即可返回。如果跨越多个块,只要你的块是连续的,类似MYSQl,基于预读机制,一次读取多个块的数据。...【详细内容】
2023-05-16  一个即将退役的码农  今日头条  Tags:ArrayList   点击:(5)  评论:(0)  加入收藏
最近这段时间小编陆续收到粉丝们的私信,提到的最多的问题就是有没有非常优秀的开源项目推荐,有没有AI相关的开源项目推荐,有没有的ChatGPT开源项目推荐等等。说句话实话,优化开...【详细内容】
2023-05-16  Echa攻城狮  今日头条  Tags:Github   点击:(6)  评论:(0)  加入收藏
作者 | Robin Guldener策划 | 言征OAuth 是一个标准协议。基本上你可以想象的每种编程语言都有 OAuth 2.0 的客户端库。但有了客户端库,却并不意味着万事大吉,如果你能够在大...【详细内容】
2023-05-16    51CTO  Tags:OAuth   点击:(8)  评论:(0)  加入收藏
大家好,我是前端西瓜哥。为了测试 Yjs 的协同能力,我实现了支持协同简单的 TODO 应用。支持的功能 创建房间; 新增、删除、完成、清空所有待办; 撤销重做; 显示其他用户的光标位...【详细内容】
2023-05-15  前端西瓜哥  微信公众号  Tags:React   点击:(8)  评论:(0)  加入收藏
大家好,我是哪吒。今天分享一下Redis布隆过滤器的原理和应用场景,解决缓存穿透,实现快速入门,丰富个人简历,提高面试level,给自己增加一点谈资,秒变面试小达人,BAT不是梦。一、缓存...【详细内容】
2023-05-15  哪吒编程  微信公众号  Tags:缓存穿透   点击:(11)  评论:(0)  加入收藏
新智元报道编辑:桃子【新智元导读】人人动嘴编程的时代,这就来了。前段时间,最大开源社区Hugging Face发布了AI聊天机器人HuggingChat,瞬间引爆全网。网友纷纷表示,如果ChatGPT是...【详细内容】
2023-05-15    新智元   Tags:Copilot   点击:(8)  评论:(0)  加入收藏
作者:vivo 互联网服务器团队- Yuan Jian Wei从内部需求出发,我们基于TiKV设计了一款兼容Redis的KV存储。基于TiKV的数据存储机制,对于窗口数据的处理以及过期数据的GC问题却成...【详细内容】
2023-05-15  OSC开源社区    Tags:KV存储   点击:(0)  评论:(0)  加入收藏
缓存,消息队列,分库分表是高并发解决方案三剑客。缓存之所以能够让系统“更快”,本质上做到了如下两点: 减小 CPU 消耗 将原来需要实时计算的内容提前算好、把一些公用的数据进...【详细内容】
2023-05-08  勇哥java实战分享    Tags:缓存   点击:(13)  评论:(0)  加入收藏
注:全民开发的英文是Citizen Development,由咨询公司Gartner在2010年提出的概念,指非专业开发人员使用低代码或无代码平台创建应用程序,无需IT部门的支持,旨在提高生产力并降低开...【详细内容】
2023-05-08  草料二维码    Tags:AI   点击:(17)  评论:(0)  加入收藏
站内最新
站内热门
站内头条