对象拷贝那些事

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/u014792352/article/details/81056879

对象拷贝那些事

拷贝方法

该文章对以下几种拷贝方式进行使用场景和性能对比进行说明。
- clone
- set
- spring beanutils
- cglib beanCopier
- stream
- orika

深拷贝 or 浅拷贝

  • 深拷贝:指源对象与拷贝对象互相独立,其中任何一个对象的改动都不会对另外一个对象造成影响。
  • 浅拷贝:指拷贝的对象根据原对象属性值拷贝一份,包括值,和内存地址,一个引用对象中值改变会影响其他对象

clone

1: 如何使用clone
实现cloneable 接口,重写clone 方法

 public class UserA implements Cloneable{
    private Long uid;
    private String name;
    private Date brithday;
    private Address address;
    @Override
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
 }

注意点:这样写的clone 是浅拷贝,当我们修改拷贝对象的address 值,原对象的address 会修改。

测试代码:

    UserA userA=new UserA();
    userA.setUid(1L);
    userA.setName("cs");
    userA.setBrithday(new Date());
    Address address=new Address();
    address.setAddress("hangzhou");
    userA.setAddress(address);

    UserA userA1=(UserA)userA.clone();
    userA1.getAddress().setAddress("quzhou");
    System.out.println("userA:"+userA.toString());
    System.out.println("userA1:"+userA1.toString());

结果:

    userA:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}
    userA1:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}

如何实现整个深拷贝?
1:Address 也实现Cloneable 类,并重写clone方法

public class Address implements Cloneable{
    private String address;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

2: 重新改造UserA 中的clone 方法

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj= super.clone();
        Address address=((UserA)obj).getAddress();
        if(Objects.nonNull(address)) {
            ((UserA) obj).setAddress((Address) address.clone());
        }
        return obj;
    }

结果:

    userA:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='hangzhou'}}
    userA1:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}

clone总结:
① 如果有一个非原生成员,如自定义对象的成员,那么就需要:
该成员实现Cloneable接口并覆盖clone()方法,不要忘记提升为public可见。
同时,修改被复制类的clone()方法,增加成员的克隆逻辑。
② 如果被复制对象不是直接继承Object,中间还有其它继承层次,每一层super类都需要实现Cloneable接口并覆盖clone()方法。

缺点:1:该clone 只能clone 赋值给该对象
2: 只能适用于简单对象,复杂对象,太麻烦

set

该方法是我们比较常用的,通过getset 方法进行设置

    @Test
    public void testSet(){
        UserA userA=new UserA();
        userA.setUid(1L);
        userA.setName("cs");
        userA.setBrithday(new Date());

        UserA userA1=new UserA();
        userA1.setUid(userA.getUid());
        userA1.setName(userA.getName());
        userA1.setBrithday(userA.getBrithday());

        userA1.setName("css");
        System.out.println("userA:"+userA.toString());
        System.out.println("userA1:"+userA1.toString());
    }

和clone 类似如果要实现深拷贝效果就要手赋值每一个对象,address 中的属性也要分别赋值

缺点:当属性多时,手写费时费力

spring beanutils

介绍

spring 提供的对象拷贝类,使用反射实现,获得目标对象属性值,根据属性去获得source readmethod 方法,如果为私有就设置 成public,然后根据属性获得target writeMethod,如果为私有就设置成public,最后writeMethod.invoke(target, value);和apache common beanutil 不同的是这个能处理date

如何使用 beanutils?

    public void testBeanUtil() {
        UserA userA=new UserA();
        userA.setUid(1L);
        userA.setName("cs");
        userA.setBrithday(new Date());
        Address address=new Address();
        address.setAddress("hangzhou");
        userA.setAddress(address);

        UserA userA1=new UserA();
        BeanUtils.copyProperties(userA,userA1);
        userA1.getAddress().setAddress("quzhou");
        System.out.println("userA:"+userA.toString());
        System.out.println("userA1:"+userA1.toString());
    }

结果:

    userA:UserA{uid=1, name='cs', brithday=Sun Jul 15 12:18:32 CST 2018, address=Address{address='quzhou'}}
    userA1:UserA{uid=1, name='cs', brithday=Sun Jul 15 12:18:32 CST 2018, address=Address{address='quzhou'}}

注意:spring beanutils 是浅拷贝,如果要是想实现深拷贝效果,就要手动对每个引用属性进行copy

缺点:随着属性增多,耗时增加明显,相互拷贝的对象需要属性名称和set 方法相同

cglib beanCopier

介绍

cglib 通过代理的方式实现拷贝,性能优于反射,扫描原来的get方法赋值给set 方法

如何使用 beanCopier?
1: 依赖

 <dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.2.4</version>
</dependency>

如果项目中引用了 spring-boot-starter-test 则不需要单独引
2:使用

    UserA userA=new UserA();
    userA.setUid(1L);
    userA.setName("cs");
    userA.setBrithday(new Date());
    Address address=new Address();
    address.setAddress("hangzhou");
    userA.setAddress(address);
    UserA userA1=new UserA();
    BeanCopier.create(UserA.class, UserA.class, false).copy(userA, userA1, null);
    userA1.getAddress().setAddress("quzhou");
    System.out.println("userA:"+userA.toString());
    System.out.println("userA1:"+userA1.toString());

结果:

    userA:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}
    userA1:UserA{uid=1, name='cs', brithday=Sun Jul 15 10:36:28 CST 2018, address=Address{address='quzhou'}}

注意:cglib 是浅拷贝,并且使用时应该对BeanCopier 进行缓存
优点:高性能,简洁

stream

如何使用?

 /**
     * This method makes a "deep clone" of any Java object it is given.
     */
    public static Object deepClone(Object object) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

注意:该方法是通过字节流输入输出进行深拷贝
缺点: 性能差

orika

介绍

官方介绍 :simpler, lighter and faster Java bean mapping
针对复杂的嵌套属性和深度结构化的对象有很好的处理方式,它将自动收集类的元数据来生成映射对象,这些映射对象可以一起使用,以递归地将数据从一个对象图复制到另一个对象图中。Orika试图提供许多方便的功能,同时保持相对简单和开放的状态——让你有可能扩展和调整它,以满足你的需要。
如何使用?
1:引用依赖

    <dependency>
          <groupId>ma.glasnost.orika</groupId>
          <artifactId>orika-core</artifactId>
          <version>1.5.2</version>
    </dependency>

2:使用

MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
MapperFacade mapper=mapperFactory.getMapperFacade();
List<UserC> userAList4=mapper.mapAsList(userAList, TypeFactory.valueOf(UserA.class),TypeFactory.valueOf(UserC.class));

3: 一些使用

指定不同名称属性直接相互转换
 mapperFactory.classMap(BasicPerson.class, BasicPersonDto.class)
    .field("name", "fullName")
    .field("age", "currentAge")
    .register();
指定不同名称属性单项转换
mapperFactory.classMap(BasicPerson.class, BasicPersonDto.class)
    .fieldAToB("name", "fullName")
    ...
    .register();
排除name 属性进行转换
 mapperFactory.classMap(BasicPerson.class, BasicPersonDto.class)
    .exclude("name")
    ...
    .register();

更多使用请参考 文章

注意:orika 是深拷贝,性能比stream 好10-20倍左右,orika 最耗时的是创建MapperFactory,和获得MapperFacade ,MapperFacade 是线程安全的,我们可以使用单例保存起来

性能测试:使用JMH微基准框架进行测试由于JVM会对热点代码进行优化:方法反射调用次数超过阈值时会生成一个专用的MethodAccessor实现类,生成其中的调用()方法的字节码进行执行。![ 这里写图片描述]

使用场景:

性能(极致,好),属性数量(多,少),层级(浅,深),属性名称(一致,不一致),代码简洁
0:同类型对象拷贝,需要性能极致,浅拷贝或(对象相对简单,层级不深的),推荐使用clone>beancopier>set>orika>beanUtil>deepcopy
1:不同类型对象拷贝,需要性能极致,并且属性数量多,层级浅,属性名称一致,需要代码简洁 推荐使用beancopier
2:不同类型对象拷贝或同类型对象,需要性能极致,并且属性数量少,层级浅,属性名称不一致 推荐set
3: 不同类型对象拷贝或同类型对象,需要性能好,并且属性数量少或多,层级深,属性名称不限,需要相互转换,推荐orika

展开阅读全文

关于android自动化测试的那些

12-12

组长叫我对公司的一个框架进行单元测试,该主要是操作图形元素,包括图片、文字、手写笔迹等所有能看得到能显示的东西,其中过程非常复杂,层次结构比较深。rn 看了单元测试相关的东西,几天过去了,感觉还是无从下手。rn 一开始我在公司框架源码src包同目录下建了一个test源码目录,然后针对src里面所有的包,都在test目录下建立了同等的包的结构。rn 叫来组长一看,他说新建一个测试项目,专门用来测试这个框架。rn 于是我重新新建了一个Android test project,然后里面可以指定你要测试哪一个项目,于是选定自己要测试的框架之后,把开始上面建立的test下面的包的结构全部移植到该测试项目中。rn 于是我认为的单元测试开始了,我找到框架最底层的数据层来进行一些测试,比如一些对数据和文件的读写操作,然后我对每个数据类的每个方法都写了一个测试方法,然后都是用一些假数据来进行测试,运行,发现正常。然后就以为这就是单元测试了。rn 数据层的好说,现在碰到了数据层上面的图形渲染和组件交互层,这些里面大都都是对一些基本图形元素的处理,里面的逻辑以及关系我看不懂,只知道大概的架构。rn 现在得问题是,对于这些图形组件之类的东西?用这种单元测试的方式,该如何来进行测试呢?该测试什么呢?求高人指导! 论坛

Java 内存的那些

02-22

虽然Java屏蔽了一下内存细节,但是有时候,了解一下这些常识还是有好处的,特别是一些面试,总是盯着这些玩意不放手。把最近看的一些总结一下,欢迎跟帖拍砖。rnrnJVM启动以后,会分配两类内存区域,一类用于开发人员使用,比如保存一些变量,对象等,一类JVM自己使用,比如存放一些class类和描述。rnrn1,第一类内存区域又可以分为栈(stack)、堆(heap),还有一些静态存储区域,这部分的内存在JVM启动的时候,可以用参数进行配置:rnrn-Xms 初始堆大小,这个值不能太小,其初始空间(即-Xms)是物理内存的1/64,这个值不能太小,比如 设置了-Xms1m,运行可能会出现 rn Error occurred during initialization of VMrn Too small initial heap for new size specifiedrnrn-Xmx 堆大小上限,最大空间(-Xmx)是物理内存的1/4,如果程序中分配的内存超过了这个限制,那么会出现rnException in thread "main" java.lang.OutOfMemoryError: Java heap spacern 代码为:byte[] b = new byte[100000000];rnrn-Xss 线程栈大小,一般不用设置,JDK5.0以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K。更具应用的线程所需内存大小进行调整。有时候会发现一下异常,rn Exception in thread "main" java.lang.StackOverflowErrorrnrn 原因一般是:rnrn public static int callMyself()rn return callMyself();rn rnrn 方法的递归或者死循环,导致栈空间不够用了。rnrn 栈和堆到底存些什么,很多地方都有讲到,这里参考下《Think in java》的,栈里存放对象引用、基本类型的变量等,而堆里面存放对象和数组。方法的执行是在栈上进行的,这一点可以通过异常的时候,经常会默认打印e.printStackTrace();栈信息得知。rnrnrnRuntime类有几个函数,我们可以简单的通过这几个函数,看看JVM中的一些内存信息,下面是转自网络上的解释。rnrnmaxMemory()这个方法返回的是java虚拟机(这个进程)能构从操作系统那里挖到的最大的内存,以字节为单位,如果在运行java程序的时 候,没有添加-Xmx参数,那么就是64兆,也就是说maxMemory()返回的大约是64*1024*1024字节,这是java虚拟机默认情况下能 从操作系统那里挖到的最大的内存。如果添加了-Xmx参数,将以这个参数后面的值为准,例如java -cp ClassPath -Xmx512m ClassName,那么最大内存就是512*1024*0124字节。rnrntotalMemory()这个方法返回的是java虚拟机现在已经从操作系统那里挖过来的内存大小,也就是java虚拟机这个进程当时所占用的所有 内存。如果在运行java的时候没有添加-Xms参数,那么,在java程序运行的过程的,内存总是慢慢的从操作系统那里挖的,基本上是用多少挖多少,直 挖到maxMemory()为止,所以totalMemory()是慢慢增大的。如果用了-Xms参数,程序在启动的时候就会无条件的从操作系统中挖- Xms后面定义的内存数,然后在这些内存用的差不多的时候,再去挖。rnrnfreeMemory()是什么呢,刚才讲到如果在运行java的时候没有添加-Xms参数,那么,在java程序运行的过程的,内存总是慢慢的从操 作系统那里挖的,基本上是用多少挖多少,但是java虚拟机100%的情况下是会稍微多挖一点的,这些挖过来而又没有用上的内存,实际上就是 freeMemory(),所以freeMemory()的值一般情况下都是很小的,但是如果你在运行java程序的时候使用了-Xms,这个时候因为程 序在启动的时候就会无条件的从操作系统中挖-Xms后面定义的内存数,这个时候,挖过来的内存可能大部分没用上,所以这个时候freeMemory()可 能会有些大。rnrnrn下面我们来看看例子:rnrn Runtime rt = Runtime.getRuntime();rn rn info("Max memory: " + rt.maxMemory());rn long fisrt = rt.freeMemory();rn info("Total memory: " + rt.totalMemory());rn info("Free memory: " + fisrt);rn rn int size = 10000;rn rn byte[] b = new byte[size];rn long bL = rt.freeMemory();rn info("Free memory: " + bL);rn info("byte allocate Cost memory: " + (fisrt - bL) + ", Array size :" + size);rnrn 运行参数为 -Xms8m -Xmx32m (太大了可能看不出来),运行结果为:rn2011-02-22 10:28:01: Max memory: 33357824rn2011-02-22 10:28:01: Total memory: 8323072rn2011-02-22 10:28:01: Free memory: 7791752rn2011-02-22 10:28:01: Free memory: 7781736rn2011-02-22 10:28:01: byte allocate Cost memory: 10016, Array size :10000rnrn 33357824 <> 32*1025*1024(大约等于)rnrn 8323072 <> 8×1024×1024rnrn 最后看看10000长度的byte数组,分配了多少内存,大约为10016,这说明除了10000个大小为1字节的byte以外,还有16个字节其他的玩意。rnrn将byte换成int(4字节):rn2011-02-22 10:35:21: int allocate Cost memory: 40016, Array size :10000rn 与byte相同,也是4*10000+16rnrn将byte换成long(8字节):rn2011-02-22 10:32:47: long allocate Cost memory: 80016, Array size :10000rn与byte相同,也是8*10000+16rnrn再看看String数组:rn2011-02-22 10:34:40: String allocate Cost memory: 40016, Array size :10000rnString作为一个对象,分配的内存大小与int相同,说明了这台机器是32(4*8)位的rnrnrn最后看看Object对象,rn2011-02-22 10:37:02: Object allocate Cost memory: 40016, Array size :10000rn与String一样。rnrnrn2,第二类内存,我了解的主要是PermGen space,全称是Permanent Generation space,是指内存的永久保存区域,这块内存主要是被JVM存放Class和Meta信息的,Class在被Loader时就会被放到PermGen space中,它和存放类实例(Instance)的Heap区域不同,SUN的JDK在GC(Garbage Collection)不会在主程序运行期对PermGen space进行清理,所以如果你的应用中有很CLASS的话,就很可能出现PermGen space错误。rnrn 原来SUN 的JVM把内存分了不同的区,其中一个就是permenter区用来存放用得非常多的类和类描述。本来SUN设计的时候认为这个区域在JVM启动的时候就固定了,但他没有想到现在动态会用得这么广泛。而且这个区域有特殊的垃圾收回机制,现在的问题是动态加载类到这个区域后,gc根本没办法回收。rn rn Permgen space的参数为-XX:PermSize=128M -XX:MaxPermSize=512mrnrn 论坛

没有更多推荐了,返回首页