AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java对象拷贝

2017-03-22 2431
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： java赋值是复制对象引用，如果我们想要得到一个对象的副本，使用赋值操作是无法达到目的的：@Testpublic void testassign(){ Person p1=new Person(); p1.

java赋值是复制对象引用，如果我们想要得到一个对象的副本，使用赋值操作是无法达到目的的：

@Test
public void testassign(){
  Person p1=new Person();
  p1.setAge(31);
  p1.setName("Peter");

  Person p2=p1;
  System.out.println(p1==p2);//true
}

如果创建一个对象的新的副本，也就是说他们的初始状态完全一样，但以后可以改变各自的状态，而互不影响，就需要用到java中对象的复制，如原生的clone()方法。

如何进行对象克隆

Object对象有个clone()方法，实现了对象中各个属性的复制，但它的可见范围是protected的，所以实体类使用克隆的前提是：

① 实现Cloneable接口，这是一个标记接口，自身没有方法。
② 覆盖clone()方法，可见性提升为public。

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

@Test
public void testShallowCopy() throws Exception{
  Person p1=new Person();
  p1.setAge(31);
  p1.setName("Peter");

  Person p2=(Person) p1.clone();
  System.out.println(p1==p2);//false
  p2.setName("Jacky");
  System.out.println("p1="+p1);//p1=Person [name=Peter, age=31]
  System.out.println("p2="+p2);//p2=Person [name=Jacky, age=31]
}

该测试用例只有两个基本类型的成员，测试达到目的了。

事情貌似没有这么简单，为Person增加一个Address类的成员：

@Data
public class Address {
    private String type;
    private String value;
}

再来测试，问题来了。

@Test
public void testShallowCopy() throws Exception{
  Address address=new Address();
  address.setType("Home");
  address.setValue("北京");

  Person p1=new Person();
  p1.setAge(31);
  p1.setName("Peter");
  p1.setAddress(address);

  Person p2=(Person) p1.clone();
  System.out.println(p1==p2);//false

  p2.getAddress().setType("Office");
  System.out.println("p1="+p1);
  System.out.println("p2="+p2);
}

查看输出：

false
p1=Person(name=Peter, age=31, address=Address(type=Office, value=北京))
p2=Person(name=Peter, age=31, address=Address(type=Office, value=北京))

遇到了点麻烦，只修改了p2的地址类型，两个地址类型都变成了Office。

浅拷贝和深拷贝

前面实例中是浅拷贝和深拷贝的典型用例。

浅拷贝：被复制对象的所有值属性都含有与原来对象的相同，而所有的对象引用属性仍然指向原来的对象。

深拷贝：在浅拷贝的基础上，所有引用其他对象的变量也进行了clone，并指向被复制过的新对象。

也就是说，一个默认的clone()方法实现机制，仍然是赋值。

如果一个被复制的属性都是基本类型，那么只需要实现当前类的cloneable机制就可以了，此为浅拷贝。

如果被复制对象的属性包含其他实体类对象引用，那么这些实体类对象都需要实现cloneable接口并覆盖clone()方法。

@Data
public class Address implements Cloneable {
    private String type;
    private String value;

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

这样还不够，Person的clone()需要显式地clone其引用成员。

@Data
public class Person implements Cloneable {
    private String name;
    private Integer age;
    private Address address;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj=super.clone();
        Address a=((Person)obj).getAddress();
        ((Person)obj).setAddress((Address) a.clone());
        return obj;
    }
}

重新跑前面的测试用例：

false
p1=Person(name=Peter, age=31, address=Address(type=Home, value=北京))
p2=Person(name=Peter, age=31, address=Address(type=Office, value=北京))

clone方式深拷贝小结

① 如果有一个非原生成员，如自定义对象的成员，那么就需要：

  • 该成员实现Cloneable接口并覆盖clone()方法，不要忘记提升为public可见。
  • 同时，修改被复制类的clone()方法，增加成员的克隆逻辑。

② 如果被复制对象不是直接继承Object，中间还有其它继承层次，每一层super类都需要实现Cloneable接口并覆盖clone()方法。

与对象成员不同，继承关系中的clone不需要被复制类的clone()做多余的工作。

一句话来说，如果实现完整的深拷贝，需要被复制对象的继承链、引用链上的每一个对象都实现克隆机制。

前面的实例还可以接受，如果有N个对象成员，有M层继承关系，就会很麻烦。

利用序列化实现深拷贝

clone机制不是强类型的限制，比如实现了Cloneable并没有强制继承链上的对象也实现；也没有强制要求覆盖clone()方法。因此编码过程中比较容易忽略其中一个环节，对于复杂的项目排查就是困难了。

要寻找可靠的，简单的方法，序列化就是一种途径。

  • 被复制对象的继承链、引用链上的每一个对象都实现java.io.Serializable接口。这个比较简单，不需要实现任何方法，serialVersionID的要求不强制，对深拷贝来说没毛病。

  • 实现自己的deepClone方法，将this写入流，再读出来。俗称：冷冻-解冻。

@Data
public class Person implements Serializable {
    private String name;
    private Integer age;
    private Address address;
    public Person deepClone() {
        Person p2=null;
        Person p1=this;
        PipedOutputStream out=new PipedOutputStream();
        PipedInputStream in=new PipedInputStream();
        try {
            in.connect(out);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try(ObjectOutputStream bo=new ObjectOutputStream(out);
                ObjectInputStream bi=new ObjectInputStream(in);) {
            bo.writeObject(p1);
            p2=(Person) bi.readObject();

        } catch (Exception e) {
            e.printStackTrace();
        }
        return p2;
    }
}

原型工厂类

为了便于测试，也节省篇幅，封装一个工厂类。

公平起见，避免某些工具库使用缓存机制，使用原型方式工厂。

public class PersonFactory{
    public static Person newPrototypeInstance(){
        Address address = new Address();
        address.setType("Home");
        address.setValue("北京");

        Person p1 = new Person();
        p1.setAddress(address);
        p1.setAge(31);
        p1.setName("Peter");
        return p1;
    }
}

利用Dozer拷贝对象

Dozer是一个Bean处理类库。

maven依赖

<dependency>
  <groupId>net.sf.dozer</groupId>
  <artifactId>dozer</artifactId>
  <version>5.5.1</version>
</dependency>

测试用例：

@Data
public class Person {
    private String name;
    private Integer age;
    private Address address;

    @Test
    public void testDozer() {
    Person p1=PersonFactory.newPrototypeInstance();
        Mapper mapper = new DozerBeanMapper();
        Person p2 = mapper.map(p1, Person.class);
        p2.getAddress().setType("Office");
        System.out.println("p1=" + p1);
        System.out.println("p2=" + p2);
    }
}

@Data
public class Address {
    private String type;
    private String value;
}

输出：

p1=Person(name=Peter, age=31, address=Address(type=Home, value=北京))
p2=Person(name=Peter, age=31, address=Address(type=Office, value=北京))

注意：在万次测试中dozer有一个很严重的问题，如果DozerBeanMapper对象在for循环中创建，效率（dozer:7358）降低近10倍。由于DozerBeanMapper是线程安全的，所以不应该每次都创建新的实例。可以自带的单例工厂DozerBeanMapperSingletonWrapper来创建mapper，或集成到spring中。

还有更暴力的，创建一个People类：

@Data
public class People {
    private String name;
    private String age;//这里已经不是Integer了
    private Address address;

    @Test
    public void testDozer() {
    Person p1=PersonFactory.newPrototypeInstance();
        Mapper mapper = new DozerBeanMapper();
        People p2 = mapper.map(p1, People.class);
        p2.getAddress().setType("Office");
        System.out.println("p1=" + p1);
        System.out.println("p2=" + p2);
    }
}

只要属性名相同，干~

继续蹂躏：

@Data
public class People {
    private String name;
    private String age;
    private Map<String,String> address;//��

    @Test
    public void testDozer() {
    Person p1=PersonFactory.newPrototypeInstance();
        Mapper mapper = new DozerBeanMapper();
        People p2 = mapper.map(p1, People.class);
        p2.getAddress().put("type", "Office");
        System.out.println("p1=" + p1);
        System.out.println("p2=" + p2);
    }
}

利用Commons-BeanUtils复制对象

maven依赖

<dependency>
  <groupId>commons-beanutils</groupId>
  <artifactId>commons-beanutils</artifactId>
  <version>1.9.3</version>
</dependency>

测试用例：

@Data
public class Person {
    private String name;
    private String age;
    private Address address;

    @Test
    public void testCommonsBeanUtils(){
    Person p1=PersonFactory.newPrototypeInstance();
        try {
            Person p2=(Person) BeanUtils.cloneBean(p1);
            System.out.println("p1=" + p1);
            p2.getAddress().setType("Office");
            System.out.println("p2=" + p2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

利用cglib复制对象

maven依赖：

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

测试用例：

@Test
public void testCglib(){
  Person p1=PersonFactory.newPrototypeInstance();
  BeanCopier beanCopier=BeanCopier.create(Person.class, Person.class, false);
  Person p2=new Person();
  beanCopier.copy(p1, p2,null);
  p2.getAddress().setType("Office");
  System.out.println("p1=" + p1);
  System.out.println("p2=" + p2);
}

结果大跌眼镜，cglib这么牛x，居然是浅拷贝。不过cglib提供了扩展能力：

@Test
public void testCglib(){
  Person p1=PersonFactory.newPrototypeInstance();
  BeanCopier beanCopier=BeanCopier.create(Person.class, Person.class, true);
  Person p2=new Person();
  beanCopier.copy(p1, p2, new Converter(){
    @Override
    public Object convert(Object value, Class target, Object context) {
      if(target.isSynthetic()){
        BeanCopier.create(target, target, true).copy(value, value, this);
      }
      return value;
    }
  });
  p2.getAddress().setType("Office");
  System.out.println("p1=" + p1);
  System.out.println("p2=" + p2);
}

Orika复制对象

orika的作用不仅仅在于处理bean拷贝，更擅长各种类型之间的转换。

maven依赖：

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

测试用例：

@Test
public void testOrika() {
  MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

  mapperFactory.classMap(Person.class, Person.class)
  .byDefault()
  .register();
  ConverterFactory converterFactory = mapperFactory.getConverterFactory();
  MapperFacade mapper = mapperFactory.getMapperFacade();

  Person p1=PersonFactory.newPrototypeInstance();
  Person p2 = mapper.map(p1, Person.class);
  System.out.println("p1=" + p1);
  p2.getAddress().setType("Office");
  System.out.println("p2=" + p2);
}

Spring BeanUtils复制对象

给Spring个面子，貌似它不支持深拷贝。

Person p1=PersonFactory.newPrototypeInstance();
Person p2 = new Person();
Person p2 = (Person) BeanUtils.cloneBean(p1);
//BeanUtils.copyProperties(p2, p1);//这个更没戏

深拷贝性能对比

@Test
public void testBatchDozer(){
  Long start=System.currentTimeMillis();
  Mapper mapper = new DozerBeanMapper();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    Person p2 = mapper.map(p1, Person.class);
  }
  System.out.println("dozer:"+(System.currentTimeMillis()-start));
  //dozer:721
}
@Test
public void testBatchBeanUtils(){
  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    try {
      Person p2=(Person) BeanUtils.cloneBean(p1);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  System.out.println("commons-beanutils:"+(System.currentTimeMillis()-start));
  //commons-beanutils：229
}
@Test
public void testBatchCglib(){
  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    BeanCopier beanCopier=BeanCopier.create(Person.class, Person.class, true);
    Person p2=new Person();
    beanCopier.copy(p1, p2, new Converter(){
      @Override
      public Object convert(Object value, Class target, Object context) {
        if(target.isSynthetic()){
          BeanCopier.create(target, target, true).copy(value, value, this);
        }
        return value;
      }
    });
  }
  System.out.println("cglib:"+(System.currentTimeMillis()-start));
  //cglib:133
}
@Test
public void testBatchSerial(){
  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    Person p2=p1.deepClone();
  }
  System.out.println("serializable:"+(System.currentTimeMillis()-start));
  //serializable:687
}
@Test
public void testBatchOrika() {
  MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

  mapperFactory.classMap(Person.class, Person.class)
  .field("name", "name")
  .byDefault()
  .register();
  ConverterFactory converterFactory = mapperFactory.getConverterFactory();
  MapperFacade mapper = mapperFactory.getMapperFacade();

  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    Person p2 = mapper.map(p1, Person.class);
  }
  System.out.println("orika:"+(System.currentTimeMillis()-start));
  //orika:83
}

@Test
public void testBatchClone(){
  Long start=System.currentTimeMillis();
  for(int i=0;i<10000;i++){
    Person p1=PersonFactory.newPrototypeInstance();
    try {
      Person p2=(Person) p1.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
  }
  System.out.println("clone:"+(System.currentTimeMillis()-start));
  //clone:8
}

（10k）性能比较：

//dozer:721
//commons-beanutils：229
//cglib:133
//serializable:687
//orika:83
//clone:8

深拷贝总结

原生的clone效率无疑是最高的，用脚趾头都能想到。

偶尔用一次，用哪个都问题都不大。

一般性能要求稍高的应用场景，cglib和orika完全可以接受。

另外一个考虑的因素，如果项目已经引入了某个依赖，就用那个依赖来做吧，没必要再引入一个第三方依赖。

文章标签：
Java
测试技术
Maven
Spring
BI
安全
缓存
关键词：
Java对象
Java拷贝
Java对象拷贝
pollyduan
目录
相关文章
java的细水长流
|
11天前
|
存储 Java
java的对象详解
在Java中，对象是根据类模板实例化的内存实体，具有唯一标识符、属性及行为。通过`new`关键字实例化对象并用构造方法初始化。变量存储的是对象引用而非对象本身，属性描述对象状态，方法定义其行为。Java利用垃圾回收机制自动处理不再使用的对象内存回收，极大地简化了对象生命周期管理，同时对象具备封装、继承和多态性，促进了代码的重用与模块化设计。这使得Java程序更易于理解、维护和扩展。
java的细水长流
219 94
2的n次方_
|
7天前
|
Java 编译器
Java——类与对象（继承和多态）
本文介绍了面向对象编程中的继承概念，包括如何避免重复代码、构造方法的调用规则、成员变量的访问以及权限修饰符的使用。文中详细解释了继承与组合的区别，并探讨了多态的概念，包括向上转型、向下转型和方法的重写。此外，还讨论了静态绑定和动态绑定的区别，以及多态带来的优势和弊端。
2的n次方_
20 9
Java——类与对象（继承和多态）
2的n次方_
|
7天前
|
SQL Java 编译器
Java——类与对象（封装）
封装是面向对象编程中的概念，指将数据（属性）和相关操作（方法）组合成独立单元（类），使外部无法直接访问对象的内部状态，只能通过提供的方法进行交互，从而保护数据安全。例如，手机将各种组件封装起来，只暴露必要的接口供外部使用。实现封装时，使用`private`关键字修饰成员变量，并提供`get`和`set`方法进行访问和修改。此外，介绍了包的概念、导入包的方式及其注意事项，以及`static`关键字的使用，包括静态变量和方法的初始化与代码块的加载顺序。
2的n次方_
18 10
Java——类与对象（封装）
2的n次方_
|
7天前
|
Java C语言
Java——类与对象
这段内容介绍了Java中的类和对象、`this`关键字及构造方法的基本概念。类是对现实世界事物的抽象描述，包含属性和方法；对象是类的实例，通过`new`关键字创建。`this`关键字用于区分成员变量和局部变量，构造方法用于初始化对象。此外，还介绍了标准JavaBean的要求和生成方法。
2的n次方_
18 9
Java——类与对象
java的细水长流
|
8天前
|
存储 Java
Java的对象和类的相同之处和不同之处
在 Java 中，对象和类是面向对象编程的核心。
java的细水长流
43 18
蓝易云
|
2天前
|
Java
Java实现：将带时区的时间字符串转换为LocalDateTime对象
通过上述方法，你可以将带时区的时间字符串准确地转换为 `LocalDateTime`对象，这对于处理不需要时区信息的日期和时间场景非常有用。
蓝易云
41 4
vohelon
|
2天前
|
SQL Java 关系型数据库
在Java中，创建数据源对象
在Java中，创建数据源对象
vohelon
9 1
历年考试不作弊
|
8天前
|
存储 Java
Java编程中的对象序列化与反序列化
【9月更文挑战第12天】在Java的世界里，对象序列化与反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何通过实现Serializable接口来标记一个类的对象可以被序列化，并探索ObjectOutputStream和ObjectInputStream类的使用，以实现对象的写入和读取。我们还将讨论序列化过程中可能遇到的问题及其解决方案，确保你能够高效、安全地处理对象序列化。
历年考试不作弊
10 1
java的细水长流
|
13天前
|
Java
Java 对象和类
在Java中，**类**（Class）和**对象**（Object）是面向对象编程的基础。类是创建对象的模板，定义了属性和方法；对象是类的实例，通过`new`关键字创建，具有类定义的属性和行为。例如，`Animal`类定义了`name`和`age`属性及`eat()`、`sleep()`方法；通过`new Animal()`创建的`myAnimal`对象即可调用这些方法。面向对象编程通过类和对象模拟现实世界的实体及其关系，实现问题的结构化解决。
java的细水长流
22 4
智物科技库
|
17天前
|
存储 Java 程序员
优化Java多线程应用：是创建Thread对象直接调用start()方法？还是用个变量调用？
这篇文章探讨了Java中两种创建和启动线程的方法，并分析了它们的区别。作者建议直接调用 `Thread` 对象的 `start()` 方法，而非保持强引用，以避免内存泄漏、简化线程生命周期管理，并减少不必要的线程控制。文章详细解释了这种方法在使用 `ThreadLocal` 时的优势，并提供了代码示例。作者洛小豆，文章来源于稀土掘金。
智物科技库
20 6

热门文章

最新文章

  • 1
    Java设计模式(一)----单例模式
  • 2
    Spring框架（SpringBoot）中redis报错（Could not get a resource from the pool、java.net.SocketTimeoutException）
  • 3
    java.io.IOException: Stream closed解决办法
  • 4
    SpringBoot运行出现 Lookup method resolution failed； nested exception is java.lang.IllegalStateException
  • 5
    JVM深入学习：Java解析Class文件过程解析
  • 6
    Java多线程之ReentrantReadWriteLock
  • 7
    Win11 系统Java17的安装教程：最新版JDK 17.07下载、安装、卸载详解
  • 8
    Redis反序列化错误Could not read JSON: Cannot construct instance of `java.util.ArrayList$SubList`
  • 9
    Java读取XML与xls文件
  • 10
    java反序列化时的类加载
  • 1
    Java集合的分类有哪些？
    74
  • 2
    java基于云部署的SaaS医院云HIS系统源码 心理CT、B超 lis、电子病历
    86
  • 3
    Java 并发编程的探索与实践
    49
  • 4
    Maven 构建 Java 项目
    56
  • 5
    18：面向切面编程-Java Spring
    76
  • 6
    17：缓存机制-Java Spring
    82
  • 7
    16：事务-Java Spring
    49
  • 8
    15：MyBatis对象关系与映射结构-Java Spring
    88
  • 9
    Java串口通信：从十六进制字符串到字节数组的正确转换与发送
    210
  • 10
    Java中如何使用Socket类检测端口是否存在
    81

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    通义千问API入门教程