Java之deep copy(深复制)
2015-05-07 17:54
1201 查看
前段时间碰到需要将一个Java对象进行深度拷贝的情况,但是JDK并未提供关于deep copy相关的API,唯一能用的就是一个不太稳定的clone(),所以问题就来了,如何实现稳定的deep copy,下面就实现deep copy的方法做个介绍。
上面的代码里,直接将test复制给test2,但是将两个对象打印出来发现,地址其实是一样的,test只是刚刚在堆上分配的Test对象的引用,而这里的赋值直接是引用直接的赋值,等于test2也是指向刚刚new出来的对象,这里的copy就是一个shallow copy,及只是copy了一份引用,但是对象实体并未copy,既然赋值不行,那就试试第二个方法,Object类的clone方法。
此外也可以自己实现一套Copyable接口,然后想要复制的类都继承该接口并复现copy函数即可。但是copy函数内的逻辑其实与复制构造类似。比如:
Copyable接口:
具体实现与测试:
首先,想要实现序列化必须实现序列化接口,也就表示所有需要深复制的类都应该实现Serializable接口,不过这倒是比较容易解决。
第二,序列化操作比较慢,其实序列化和反序列化两个操作是比较耗时的,这虽然可以通过自己来实现一套writeObject和readObject来解决,但是这里始终都是瓶颈。
第三,序列化操作中ByteArrayInputStream和ByteArrayOutputStream是线程安全的,一般情况下这没什么问题,但是当本身业务中不涉及到多线程情况的话这就会拖慢deep copy的速度。
其中第二点实现比较麻烦且速度提升不明显,但是在不涉及多线程的情况下,第三条却可以得到改变,我们可以自己实现非线程安全的InputStream和OutputStream的子类去替换ByteArrayInputStream和ByteArrayOutputStream,从而提升速度。
总结一下,实现deep copy,主要的方法有:
实现Cloneable接口并覆写clone方法
使用复制构造函数
自定义一个Copyable接口,然后为需要clone的类增加copy方法的具体实现
通过序列化方式将一个对象先序列化再反序列化得到一个deep copy的新对象
使用成熟第三方库,具体方法看文档。
1. 直接赋值
实现deep copy,首先想到的是可以直接赋值么?如下:Test test = new Test(); Test test2 = test; System.out.println(test); System.out.println(test2);
上面的代码里,直接将test复制给test2,但是将两个对象打印出来发现,地址其实是一样的,test只是刚刚在堆上分配的Test对象的引用,而这里的赋值直接是引用直接的赋值,等于test2也是指向刚刚new出来的对象,这里的copy就是一个shallow copy,及只是copy了一份引用,但是对象实体并未copy,既然赋值不行,那就试试第二个方法,Object类的clone方法。
2. clone方法
1. clone方法介绍
Java中所有对象都继承自Object类,所以就默认自带clone方法的实现,clone方法的实现是比较简单粗暴的。首先,如果一个对象想要调用clone方法,必须实现Cloneable接口,否则会抛出CloneNotSupportedException。其实这个Cloneable是个空接口,只是个flag用来标记这个类是可以clone的,所以说将一个类声明为Cloneable与这个类具备clone能力其实并不是直接相关的。其实Cloneable是想表明具有复制这种功能,所以按理说clone应该作为Cloneable的一个方法而存在,但是实际上clone方法是Object类的一个protected方法,所以你无法直接通过多态的方式调用clone方法,比如:public class Test implements Cloneable { public static void main(String[] args) { try { List<Cloneable> list = new ArrayList<Cloneable>(); Cloneable t1 = new InnerTest("test"); list.add(t1); list.add(t1.clone()); // 事实上,我无法这么做 } catch (Exception e) { e.printStackTrace(); } } public static class InnerTest implements Cloneable { public String a; public InnerTest(String test) { a = test; } public Object clone() throws CloneNotSupportedException { return super.clone(); } } }这其实是设计上的一个缺陷,不过导致clone方法声名狼藉的并不单单因为这个。
2. clone是深复制还是浅复制
当调用clone方法时,首先会直接分配内存,然后将原对象内所有的字段都一一复制,如果字段是基本类型数据比如int之类的,则这样直接的赋值式的复制毫无问题,但是如果字段是引用的话问题就来了,引用也会原封不动的复制一份,就如同第一个例子一样。所以,很多情景下,clone只能算一个半deep半shallow的复制方法。想要解决这个问题,唯一的方法就是在需要被复制的对象的clone方法内调用会被shallow copy的对象的clone方法,但是前提是该对象也继承了Cloneable接口并Override了clone方法。比如:public class Test implements Cloneable { public static void main(String[] args) { try { InnerTest t1 = new InnerTest(new InnerTest2()); InnerTest t2 = (InnerTest) t1.clone(); System.out.println(t1); // Test$InnerTest@232204a1 System.out.println(t2); // Test$InnerTest@4aa298b7 } catch (Exception e) { e.printStackTrace(); } } public static class InnerTest implements Cloneable { public InnerTest2 test; public InnerTest(InnerTest2 test) { this.test = test; } @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } } public static class InnerTest2 implements Cloneable { public InnerTest2() { } @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } } }
3. clone跳过构造函数
此外,clone方法不通过构造函数来创建新对象,所以构造函数内的逻辑也会被直接跳过,这也会带来问题,等于clone引进了一个我们无法控制的对象构造方法。比如想在构造函数内实现一个计数功能,每次new就加1,但是如果clone的话,则这个计数就无法生效。比如:public class Test implements Cloneable { public static void main(String[] args) { try { List<Cloneable> list = new ArrayList<Cloneable>(); InnerTest t1 = new InnerTest("test"); InnerTest t2 = new InnerTest("test1"); list.add(t1); list.add(t2); list.add((Cloneable) t1.clone()); for (Cloneable c : list) { System.out.println(((InnerTest) c).index ); // 依次打印 0 1 0 } System.out.println(InnerTest.count); // count为2 } catch (Exception e) { e.printStackTrace(); } } public static class InnerTest implements Cloneable { public int index; public static int count = 0; public InnerTest(String test) { index = count; count++; } public Object clone() throws CloneNotSupportedException { return super.clone(); } } }
4. 最佳实践——复制构造函数或者自定义Copyable接口
另外clone方法本身也是线程不安全的。所以总结下来就是clone是很不靠谱的,所以主流的建议还是添加复制构造函数,这样虽然会比较麻烦一点,但是可控性强且可以实现deep copy。此外也可以自己实现一套Copyable接口,然后想要复制的类都继承该接口并复现copy函数即可。但是copy函数内的逻辑其实与复制构造类似。比如:
Copyable接口:
public interface Copyable<T> { T copy (); }
具体实现与测试:
public class Test{ public static void main(String[] args) { try { InnerTest t1 = new InnerTest(new InnerTest2()); InnerTest t2 = t1.copy(); System.out.println(t1.test.getA()); // print 0 t1.test.setA(5); System.out.println(t2.test.getA()); // print 0 } catch (Exception e) { e.printStackTrace(); } } // 测试类 public static class InnerTest implements Copyable<InnerTest> { // set to public for convenience public InnerTest2 test; public InnerTest(InnerTest2 tmp) { this.test = tmp; } @Override public InnerTest copy() { InnerTest2 tmp = test == null ? null : test.copy(); return new InnerTest(tmp); } } // 测试类,增加getter和setter方法来验证 public static class InnerTest2 implements Copyable<InnerTest2>{ private int a; public InnerTest2() { a = 0; } public int getA() { return a; } public void setA(int a) { this.a = a; } @Override public InnerTest2 copy() { InnerTest2 tmp = new InnerTest2(); tmp.setA(this.a); return tmp; } } }
3. 序列化实现深复制
1. 为什么使用序列化
其实大部分情况下复制构造是个不错的选择,但是实现上来说确实比较繁琐,且容易出错,因为需要递归式的将所有的对象和它引用的对象都进行复制,所以就有了另外一种实现deep copy的思路:Java Object Serialization (JOS)。序列化会将一个对象的各个方面都考虑到,包括父类,各个字段,以及各种引用。所以如果将一个对象先序列化写入字节流,然后再读出,重新构造成一个对象,就能实现这个对象的deep copy。当然,这里其实也没考虑构造函数逻辑,但是这种方法却不需要考虑会有shallow copy的可能,而且省去了繁琐的复制构造或者copy方法的覆写,我们可以直接通过一个实现一个deepCopy函数来实现对象复制。下面就对这种方法做一个介绍。2. 深复制的实现
如何实现deepCopy函数,下面提供一个简单的例子:public class Test2 { public static Object deepCopy(Object from) { Object obj = null; try { // 将对象写成 Byte Array ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(bos); out.writeObject(from); out.flush(); out.close(); // 从流中读出 byte array,调用readObject函数反序列化出对象 ObjectInputStream in = new ObjectInputStream( new ByteArrayInputStream(bos.toByteArray())); obj = in.readObject(); } catch(IOException e) { e.printStackTrace(); } catch(ClassNotFoundException e2) { e2.printStackTrace(); } return obj; } }通过上面的例子,我们之间调用deepCopy函数就可以将一个对象进行deep copy并且返回一个新的对象。这里的writeObject和readObject分别将对象序列化和反序列化。
3.序列化存在的问题
这种方法看上去比较简单,但是其实仍然存在很多问题:首先,想要实现序列化必须实现序列化接口,也就表示所有需要深复制的类都应该实现Serializable接口,不过这倒是比较容易解决。
第二,序列化操作比较慢,其实序列化和反序列化两个操作是比较耗时的,这虽然可以通过自己来实现一套writeObject和readObject来解决,但是这里始终都是瓶颈。
第三,序列化操作中ByteArrayInputStream和ByteArrayOutputStream是线程安全的,一般情况下这没什么问题,但是当本身业务中不涉及到多线程情况的话这就会拖慢deep copy的速度。
其中第二点实现比较麻烦且速度提升不明显,但是在不涉及多线程的情况下,第三条却可以得到改变,我们可以自己实现非线程安全的InputStream和OutputStream的子类去替换ByteArrayInputStream和ByteArrayOutputStream,从而提升速度。
4. 使用相关第三方库
前面说到的几种方案都是各有优缺点,要么就是实现比较繁琐,要么就是功能不够稳定,一般这个时候可以看下是否有相关功能的成熟的类库,事实是关于deep copy的第三方库很多,比如Dozer(https://github.com/DozerMapper/dozer),Kryo(https://github.com/EsotericSoftware/kryo),cloning(https://github.com/kostaskougios/cloning)等,使用成熟类库可以很快且高效的实现deep copy,具体的发放此处不赘述,直接看github上文档即可。总结一下,实现deep copy,主要的方法有:
实现Cloneable接口并覆写clone方法
使用复制构造函数
自定义一个Copyable接口,然后为需要clone的类增加copy方法的具体实现
通过序列化方式将一个对象先序列化再反序列化得到一个deep copy的新对象
使用成熟第三方库,具体方法看文档。
相关文章推荐
- Java io copy 复制文件的几种场景
- 自定义方法copy数组 和 Java类库对数组复制的支持
- 复制D:\\day05目录下的所有文件到D:\\copy,并将.txt文件改为.java文件。
- Difference between shallow copy and deep copy? 浅复制和深复制的区别
- java读取excel文件并复制(copy)文件到指定目录示例
- Java中实现复制文件或文件夹——CopyUtil.java
- LeetCode138 Copy List with Random Pointer(深度复制带有随机指针的链表) Java题解
- 【java performance】使用'System.arraycopy ()'代替通过来循环复制数组
- Java中实现复制文件或文件夹——CopyUtil.java
- Java NIO——与传统IO文件复制的效率比较(channel.transferTo、Files.copy 、channel.write)
- [Java错误]使用Collections中的copy方法复制ArrayList产生的错误
- Java数组的复制Arrays.copyOf()、System.arraycopy()、nums.clone()
- 设计一程序(Copy.java),可以实现文件的复制操作
- Java deep copy
- [java]数组复制小结 for 、clone、 System.arraycopy
- Java使用System.arraycopy复制数组
- Java基础之访问文件与目录——移动或复制文件和目录(MoveAndCopyFiles)
- java语言——对象的深复制(deep clone)与浅复制(shallow clone)
- Java Generic Deep Copy
- 对象复制帮助类---DeepCopy