个人中心
gpt4 book ai didi

探讨java深拷贝

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章探讨java深拷贝由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

本文将讨论以下4个问题 。

    1. java Cloneable接口实现深拷贝     2. java 序列化实现深拷贝     3. 号称最快的深拷贝二方库cloning源码分析     4. 几种拷贝方式速度的比较 。

深拷贝的概念本文就不说了。在C++中实现深拷贝一般情况下重载赋值操作符 “=” 来实现同一个类的对象间的深拷贝，所以很自然的在java中我们也同样可以定义一个copy函数，在函数内部为对象的每一个属性作赋值操作。这种方式简单自然，但存在一个致命性的问题：如果有一天在类中新增加了一个需要深拷贝的属性，那么相应的copy函数也得进行修改，这种方法给类的可扩展性带来了极大的不方便。怎么解决这种问题，且看接下来的1、2、3章节的实现方式和4节的速度测试。 1. java Cloneable接口实现深拷贝 这种方式，需要类实现Colneable接口 clone 函数，在clone函数中调用super.clone。这种方式的深拷贝同样会带来另一个问题，如果类中有其他类的对象作为属性，则其他的类也需要重载并实现Cloneable接口。来一个例子，在下例中ComplexDO中包含了SimpleDO对象，要实现ComplexDO深拷贝，则需要先实现SimpleDO的clone接口:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class SimpleDO implements Cloneable, Serializable {
     private int x = 1 ;
     private String s = "simpleDO" ;
 
     @Override
     protected Object clone() throws CloneNotSupportedException {
       SimpleDO newClass = (SimpleDO) super .clone();
       return newClass;
     }
   }
 
   public class ComplexDO implements Cloneable, Serializable {
     private int x = 1 ;
     private String s = "complex" ;
     private Integer a = 123 ;
     private Integer b = 1234 ;
     private Integer c = 1334455 ;
     private String s2 = "hehehe" ;
     private String s3 = "hahahaha" ;
     private Long id = 1233245L;
     private ArrayList<SimpleDO> l = new ArrayList<SimpleDO>();
 
     @Override
     public Object clone() throws CloneNotSupportedException {
       ComplexDO newClass = (ComplexDO) super .clone();
       newClass.l = new ArrayList<SimpleDO>();
       for (SimpleDO simple : this .l) {
         newClass.l.add((SimpleDO) simple.clone());
       }
       return newClass;
     }
   }

需要注意的是很多文章说String类型的对象赋值操作符是深拷贝，但是其实在java中使用赋值操作符的都属于浅拷贝，但为什么这么明显的错误这么多的文章会非要说这个是深拷贝呢？我的理解是String、类型的属性都是基本类型，而且提供的方法只要是设计到内部数据的变动都会new一个新的对象出来。所以一个String的操作不会影响到其原先指向的内存。所以一般说String等基础类的赋值操作为深拷贝。 由于这个原因，在使用String字符串拼接的时候，需要开辟新的内存，所以很多人建议用StringBuilder来代替String来做拼接，因为StringBuilder只有在内置的char数组范围不够的时候才重新申请更大的内存(对于现代JVM，会对代码调优，String+String会被优化成StringBuilder.append的相类似的指令)。与拼接相对的裁剪，在String有个subString函数，当使用subString函数时，新String的内部char数组和原String是否相同？这个比较有意思，感兴趣的可以对比看看JDK1.6和JKD1.7的实现。 2. java 序列化实现深拷贝 这种方式的原理是利用java序列化，将一个对象序列化成二进制字节流，然后对该字节流反序列化赋值给一个对象。代码示例:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public Object seirCopy(Object src) {
    try {
      ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
      ObjectOutputStream out = new ObjectOutputStream(byteOut);
      out.writeObject(src);
 
      ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
      ObjectInputStream in = new ObjectInputStream(byteIn);
      Object dest = in.readObject();
      return dest;
    } catch (Exception e) {
      //do some error handler
      return null ;
    }
}

当然，也可以选用json等序列化的库来完成序列化，这种方式有效的规避了Cloneabel接口的可扩展缺点，一个函数就可以基本上适用于所有的类.缺点是相对内存拷贝，序列化需要先将对象转换成二进制字节流，然后反序列化将该二进制字节流重新拷贝到一块对象内存，相对慢点。 3. 号称最快的深拷贝二方库cloning源码分析 在源码中，核心的处理逻辑在Cloner类中， 分两条递归链路:

  • （1）deepClone->cloneInternal->fastClone->cloneInternal
  • （2）deepClone->cloneInternal->cloneObject->cloneInternal

在（1）中fastClone完成的是继承自IfastCloner接口类的对象，即都是些集合操作的拷贝； 在（2）中cloneObject完成的是通过反射机制拿到普通对象的每一个属性，然后对使用Objenesis新生成对象的属性赋值。 这种方式可扩展性强，不仅可以依靠其现有的代码完成深拷贝，还可以自己定义一些克隆的方式和不需要克隆的类型，灵活性强。 4. 几种拷贝方式速度的比较 上述3中模式都可以完成深拷贝，那种拷贝的方式速度最快是我们所关心的。 先上测试代码：   。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public void testCloneComplex() throws CloneNotSupportedException {
   final int copyCount = 1 ;
   List<ComplexDO> complexDOList = new ArrayList<ComplexDO>(copyCount * 3 );
   final ComplexDO complex = new ComplexDO();
 
   //调用二方库
   long start = System.currentTimeMillis();
   for ( int i = 0 ; i < copyCount; ++i) {
     final ComplexDO deepClone = cloner.deepClone(complex);
     complexDOList.add(deepClone);
   }
   long end = System.currentTimeMillis();
   System.out.println( "deepClone cost time=" + (end-start));
 
   //调用Cloneable接口实现的clone函数
   start = System.currentTimeMillis();
   for ( int i = 0 ; i < copyCount; ++i) {
     final ComplexDO interfaceClone = (ComplexDO) complex.clone();
     complexDOList.add(interfaceClone);
   }
   end = System.currentTimeMillis();
   System.out.println( "interfaceClone cost time=" + (end-start));
 
   //序列化与反序列化生成新对象
   start = System.currentTimeMillis();
   for ( int i = 0 ; i < copyCount; ++i) {
     final ComplexDO seirClone = seirCopy(complex);
     complexDOList.add(seirClone);
   }
   end = System.currentTimeMillis();
   System.out.println( "seirClone cost time=" + (end-start));
}

探讨java深拷贝

运行结果的单位为毫秒（此数据忽略不计算java热点和可能的gc）.

从这个表可以得出结论:

1、实现Cloneable接口的拷贝是最快的，因为他只涉及到了内存拷贝，但是如果涉及的属性为普通对象比较多的时候写起来麻烦点 2、序列化/反序列化拷贝最慢 3、使用cloning库，由于使用了递归和反射机制相对Cloneable接口实现的拷贝要慢，但比序列化方式要快.

以上就是本文的全部内容，希望对大家的学习有所帮助.

最后此篇关于探讨java深拷贝的文章就讲到这里了,如果你想了解更多关于探讨java深拷贝的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： Java类初始化和实例化中的2个“雷区”
文章推荐： 理解java中的深复制和浅复制
文章推荐： Java棋类游戏实践之中国象棋
文章推荐： Java棋类游戏实践之单机版五子棋
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com