Java学习之深拷贝浅拷贝及对象拷贝的两种方式

I. Java之Clone

0. 背景

对象拷贝,是一个非常基础的内容了,为什么会单独的把这个领出来讲解,主要是先前遇到了一个非常有意思的场景

有一个任务,需要解析类xml标记语言,然后生成document对象,之后将会有一系列针对document对象的操作

通过实际的测试,发现生成Document对象是比较耗时的一个操作,再加上这个任务场景中,需要解析的xml文档是固定的几个,那么一个可以优化的思路就是能不能缓存住创建后的Document对象,在实际使用的时候clone一份出来

1. 内容说明

看到了上面的应用背景,自然而言的就会想到深拷贝了,本篇博文则主要内容如下

  • 介绍下两种拷贝方式的区别
  • 深拷贝的辅助工具类
  • 如何自定义实现对象拷贝

II. 深拷贝和浅拷贝

0. 定义说明

深拷贝

相当于创建了一个新的对象,只是这个对象的所有内容,都和被拷贝的对象一模一样而已,即两者的修改是隔离的,相互之间没有影响

浅拷贝

也是创建了一个对象,但是这个对象的某些内容(比如A)依然是被拷贝对象的,即通过这两个对象中任意一个修改A,两个对象的A都会受到影响

看到上面两个简单的说明,那么问题来了

  • 浅拷贝中,是所有的内容公用呢?还是某些内容公用?
  • 从隔离来将,都不希望出现浅拷贝这种方式了,太容易出错了,那么两种拷贝方式的应用场景是怎样的?

1. 浅拷贝

一般来说,浅拷贝方式需要实现Cloneable接口,下面结合一个实例,来看下浅拷贝中哪些是独立的,哪些是公用的

@Data
public class ShallowClone implements Cloneable {

    private String name;

    private int age;

    private List<String> books;


    public ShallowClone clone() {
        ShallowClone clone = null;
        try {
            clone = (ShallowClone) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }


    public static void main(String[] args) {
        ShallowClone shallowClone = new ShallowClone();
        shallowClone.setName("SourceName");
        shallowClone.setAge(28);
        List<String> list = new ArrayList<>();
        list.add("java");
        list.add("c++");
        shallowClone.setBooks(list);


        ShallowClone cloneObj = shallowClone.clone();


        // 判断两个对象是否为同一个对象(即是否是新创建了一个实例)
        System.out.println(shallowClone == cloneObj);

        // 修改一个对象的内容是否会影响另一个对象
        shallowClone.setName("newName");
        shallowClone.setAge(20);
        shallowClone.getBooks().add("javascript");
        System.out.println("source: " + shallowClone.toString() + "\nclone:" + cloneObj.toString());
        
        shallowClone.setBooks(Arrays.asList("hello"));
        System.out.println("source: " + shallowClone.toString() + "\nclone:" + cloneObj.toString());
    }
}

输出结果:

false
source: ShallowClone(name=newName, age=20, books=[java, c++, javascript])
clone:ShallowClone(name=SourceName, age=28, books=[java, c++, javascript])
source: ShallowClone(name=newName, age=20, books=[hello])
clone:ShallowClone(name=SourceName, age=28, books=[java, c++, javascript])

结果分析:

  • 拷贝后获取的是一个独立的对象,和原对象拥有不同的内存地址
  • 基本元素类型,两者是隔离的(虽然上面只给出了int,String)
    • 基本元素类型包括:
    • int, Integer, long, Long, char, Charset, byte,Byte, boolean, Boolean, float,Float, double, Double, String
  • 非基本数据类型(如基本容器,其他对象等),只是拷贝了一份引用出去了,实际指向的依然是同一份

其实,浅拷贝有个非常简单的理解方式:

浅拷贝的整个过程就是,创建一个新的对象,然后新对象的每个值都是由原对象的值,通过 = 进行赋值

这个怎么理解呢?

上面的流程拆解就是:

- Object clone = new Object();
- clone.a = source.a
- clone.b = source.b
- ...

那么=赋值有什么特点呢?

基本数据类型是值赋值;非基本的就是引用赋值

2. 深拷贝

深拷贝,就是要创建一个全新的对象,新的对象内部所有的成员也都是全新的,只是初始化的值已经由被拷贝的对象确定了而已

那么上面的实例改成深拷贝应该是怎样的呢?

可以加上这么一个方法

public ShallowClone deepClone() {
    ShallowClone clone = new ShallowClone();
    clone.name = this.name;
    clone.age = this.age;
    if (this.books != null) {
        clone.books = new ArrayList<>(this.books);
    }
    return clone;
}


// 简单改一下测试case
public static void main(String[] args) {
    ShallowClone shallowClone = new ShallowClone();
    shallowClone.setName("SourceName");
    shallowClone.setAge(new Integer(1280));
    List<String> list = new ArrayList<>();
    list.add("java");
    list.add("c++");
    shallowClone.setBooks(list);


    ShallowClone cloneObj = shallowClone.deepClone();


    // 判断两个对象是否为同一个对象(即是否是新创建了一个实例)
    System.out.println(shallowClone == cloneObj);

    // 修改一个对象的内容是否会影响另一个对象
    shallowClone.setName("newName");
    shallowClone.setAge(2000);
    shallowClone.getBooks().add("javascript");
    System.out.println("source: " + shallowClone.toString() + "\nclone:" + cloneObj.toString());


    shallowClone.setBooks(Arrays.asList("hello"));
    System.out.println("source: " + shallowClone.toString() + "\nclone:" + cloneObj.toString());
}

输出结果为:

false
source: ShallowClone(name=newName, age=2000, books=[java, c++, javascript])
clone:ShallowClone(name=SourceName, age=1280, books=[java, c++])
source: ShallowClone(name=newName, age=2000, books=[hello])
clone:ShallowClone(name=SourceName, age=1280, books=[java, c++])

结果分析:

  • 深拷贝独立的对象
  • 拷贝后对象的内容,与原对象的内容完全没关系,都是独立的

简单来说,深拷贝是需要自己来实现的,对于基本类型可以直接赋值,而对于对象、容器、数组来讲,需要创建一个新的出来,然后重新赋值

3. 应用场景区分

深拷贝的用途我们很容易可以想见,某个复杂对象创建比较消耗资源的时候,就可以缓存一个蓝本,后续的操作都是针对深clone后的对象,这样就不会出现混乱的情况了

那么浅拷贝呢?感觉留着是一个坑,一个人修改了这个对象的值,结果发现对另一个人造成了影响,真不是坑爹么?

假设又这么一个通知对象长下面这样

private String notifyUser;

// xxx

private List<String> notifyRules;

我们现在随机挑选了一千个人,同时发送通知消息,所以需要创建一千个上面的对象,这些对象中呢,除了notifyUser不同,其他的都一样

在发送之前,突然发现要临时新增一条通知信息,如果是浅拷贝的话,只用在任意一个通知对象的notifyRules中添加一调消息,那么这一千个对象的通知消息都会变成最新的了;而如果你是用深拷贝,那么苦逼的得遍历这一千个对象,每个都加一条消息了


III. 对象拷贝工具

上面说到,浅拷贝,需要实现Clonebale接口,深拷贝一般需要自己来实现,那么我现在拿到一个对象A,它自己没有提供深拷贝接口,我们除了主动一条一条的帮它实现之外,有什么辅助工具可用么?

对象拷贝区别与clone,它可以支持两个不同对象之间实现内容拷贝

Apache的两个版本:(反射机制)

org.apache.commons.beanutils.PropertyUtils.copyProperties(Object dest, Object orig)


org.apache.commons.beanutils.BeanUtils#cloneBean

Spring版本:(反射机制)

org.springframework.beans.BeanUtils.copyProperties(Object source, Object target, Class editable, String[] ignoreProperties)

cglib版本:(使用动态代理,效率高)

net.sf.cglib.beans.BeanCopier.copy(Object paramObject1, Object paramObject2, Converter paramConverter)

从上面的几个有名的工具类来看,提供了两种使用者姿势,一个是反射,一个是动态代理,下面分别来看两种思路

1. 借助反射实现对象拷贝

通过反射的方式实现对象拷贝的思路还是比较清晰的,先通过反射获取对象的所有属性,然后修改可访问级别,然后赋值;再获取继承的父类的属性,同样利用反射进行赋值

上面的几个开源工具,内部实现封装得比较好,所以直接贴源码可能不太容易一眼就能看出反射方式的原理,所以简单的实现了一个, 仅提供思路

public static void copy(Object source, Object dest) throws Exception {
    Class destClz = dest.getClass();

    // 获取目标的所有成员
    Field[] destFields = destClz.getDeclaredFields();
    Object value;
    for (Field field : destFields) { // 遍历所有的成员,并赋值
        // 获取value值
        value = getVal(field.getName(), source);

        field.setAccessible(true);
        field.set(dest, value);
    }
}


private static Object getVal(String name, Object obj) throws Exception {
    try {
        // 优先获取obj中同名的成员变量
        Field field = obj.getClass().getDeclaredField(name);
        field.setAccessible(true);
        return field.get(obj);
    } catch (NoSuchFieldException e) {
        // 表示没有同名的变量
    }

    // 获取对应的 getXxx() 或者 isXxx() 方法
    name = name.substring(0, 1).toUpperCase() + name.substring(1);
    String methodName = "get" + name;
    String methodName2 = "is" + name;
    Method[] methods = obj.getClass().getMethods();
    for (Method method : methods) {
        // 只获取无参的方法
        if (method.getParameterCount() > 0) {
            continue;
        }

        if (method.getName().equals(methodName)
                || method.getName().equals(methodName2)) {
            return method.invoke(obj);
        }
    }

    return null;
}

上面的实现步骤还是非常清晰的,首先是找同名的属性,然后利用反射获取对应的值

Field field = obj.getClass().getDeclaredField(name);
field.setAccessible(true);
return field.get(obj);

如果找不到,则找getXXX, isXXX来获取

2. 代理的方式实现对象拷贝

Cglib的BeanCopier就是通过代理的方式实现拷贝,性能优于反射的方式,特别是在大量的数据拷贝时,比较明显

代理,我们知道可以区分为静态代理和动态代理,简单来讲就是你要操作对象A,但是你不直接去操作A,而是找一个中转porxyA, 让它来帮你操作对象A

那么这种技术是如何使用在对象拷贝的呢?

我们知道,效率最高的对象拷贝方式就是Getter/Setter方法了,前面说的代理的含义指我们不直接操作,而是找个中间商来赚差价,那么方案就出来了

将原SourceA拷贝到目标DestB

  • 创建一个代理 copyProxy
  • 在代理中,依次调用 SourceA的get方法获取属性值,然后调用DestB的set方法进行赋值

实际上BeanCopier的思路大致如上,具体的方案当然就不太一样了, 简单看了一下实现逻辑,挺有意思的一块,先留个坑,后面单独开个博文补上

说明

从实现原理和通过简单的测试,发现BeanCopier是扫描原对象的getXXX方法,然后赋值给同名的 setXXX 方法,也就是说,如果这个对象中某个属性没有get/set方法,那么就无法赋值成功了


IV. 小结

1. 深拷贝和浅拷贝

深拷贝

相当于创建了一个新的对象,只是这个对象的所有内容,都和被拷贝的对象一模一样而已,即两者的修改是隔离的,相互之间没有影响

  • 完全独立

浅拷贝

也是创建了一个对象,但是这个对象的某些内容(比如A)依然是被拷贝对象的,即通过这两个对象中任意一个修改A,两个对象的A都会受到影响

  • 等同与新创建一个对象,然后使用=,将原对象的属性赋值给新对象的属性
  • 需要实现Cloneable接口

2. 对象拷贝的两种方法

通过反射方式实现对象拷贝

主要原理就是通过反射获取所有的属性,然后反射更改属性的内容

通过代理实现对象拷贝

将原SourceA拷贝到目标DestB

创建一个代理 copyProxy 在代理中,依次调用 SourceA的get方法获取属性值,然后调用DestB的set方法进行赋值

V. 其他

声明

尽信书则不如,已上内容,纯属一家之言,因本人能力一般,见解不全,如有问题,欢迎批评指正

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏用户2442861的专栏

Python中GBK, UTF-8和Unicode的编码问题

编码问题,一直是使用python2时的一块心病。几乎所有的控制台输入输出、IO操作和HTTP操作都会涉及如下的编码问题:

31110
来自专栏www.96php.cn

PHP关键字、PHP 语言结构(Language constructs)和函数的区别

1、 什么是语言结构和函数 语言结构: 就是PHP语言的关键词,语言语法的一部分; 它不可以被用户定义或者添加到语言扩展或者库中; ...

43190
来自专栏前端儿

ES6笔记(5)-- Generator生成器函数

Generator的声明方式类似一般的函数声明,只是多了个*号,并且一般可以在函数内看到yield关键字

9810
来自专栏韩伟的专栏

框架设计原则和规范(二)

此文是《.NET:框架设计原则、规范》的读书笔记,本文内容较多,共分九章,将分4天进行推送,今天推送4-5章。 1. 什么是好的框架 2. 框架设计...

31450
来自专栏木木玲

Reference 、ReferenceQueue 详解

38370
来自专栏ShaoYL

OC内存管理

39690
来自专栏C/C++基础

C++inline函数简介

inline函数是由inline关键字来定义,引入inline函数的主要原因是用它替代C中复杂易错不易维护的宏函数。

27520
来自专栏java一日一条

(转)Java中的System类

System类代表系统,系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

11120
来自专栏码云1024

python简明笔记

通过 for 语句我们可以使用 for 循环。Python 里的 for 循环与 C 语言中的不同。这里的 for 循环遍历任何序列(比如列表和字符串)中的每一...

64190
来自专栏好好学java的技术栈

Java面试2018常考题目汇总

Linux起源于1991年,1995年流行起来的免费操作系统,目前, Linux是主流的服务器操作系统, 广泛应用于互联网、云计算、智能手机(Android)等...

13630

扫码关注云+社区

领取腾讯云代金券