本文实例讲述了Java深度复制功能与用法。分享给大家供大家参考，具体如下：
写在前面：
什么是深度复制？在Java里面，在创建一个对象，我们通常会有一个引用指向该对象，当我们通过引用变量改变对象的值（属性）时，引用是不变的，变的是内存里面的那块内存，即引用所指向的对象。一般情况下，我们将该引用赋给另一个引用变量或者作为参数传递时，传递的也只是引用，即将引用指向“复制”了一份给另一个引用变量，随后该引用变量也指向同一个对象，内存里面并没有创建一个新的对象。在某些情况下，我们需要“真正复制”对象，创建一份已知对象的copy，而不仅仅“复制”引用，用作备份也好，其他操作也好。
那么，该如何实现？
先说下思路：首先将对象序列化到流里，然后再反序列化，从流里读取出来即可。
下面上代码：
|
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
package com.yo.java;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;import java.util.ArrayList;import java.util.List;/** * Java 实现深度复制 * @author Yo * */public class DeepCopy implements Serializable{ int i; /** * @param args * @throws IOException * @throws ClassNotFoundException */ public static void main(String[] args) throws ClassNotFoundException, IOException { demo1(); demo2(); } /** * 深度复制，实参类必须实现Serializable接口 * @param o * @return * @throws IOException * @throws ClassNotFoundException */ public static Object deepCopy(Object o) throws IOException, ClassNotFoundException {// //先序列化，写入到流里 ByteArrayOutputStream bo = new ByteArrayOutputStream(); ObjectOutputStream oo = new ObjectOutputStream(bo); oo.writeObject(o); //然后反序列化，从流里读取出来，即完成复制 ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray()); ObjectInputStream oi = new ObjectInputStream(bi); return oi.readObject(); } /** * 引用传递与深度复制 * @throws ClassNotFoundException * @throws IOException */ public static void demo1() throws ClassNotFoundException, IOException { System.out.println("===========未使用深度复制========="); DeepCopy dc1 = new DeepCopy(); dc1.i = 1;//初始化dc1里i的值 DeepCopy dc2 = dc1; dc1.i = 2;//改变dc1里i的值 System.out.println("dc1 : " + dc1.i); System.out.println("dc2(引用传递) : " + dc2.i); System.out.println("===========使用深度复制========="); DeepCopy dc3 = new DeepCopy(); dc3.i = 1;//初始化dc3里i的值 DeepCopy dc4 = (DeepCopy)deepCopy(dc3); dc3.i = 2;//改变dc3里i的值 System.out.println("dc3 : " + dc3.i); System.out.println("dc4(深度复制) : " + dc4.i); } /** * 集合的值复制与深度复制 * @throws ClassNotFoundException * @throws IOException */ public static void demo2() throws ClassNotFoundException, IOException { System.out.println("===========未使用深度复制========="); //创建DeepCopy对象，并初始化i的值，添加到list1集合 DeepCopy dc = new DeepCopy(); dc.i = 1;//初始化dc1里i的值 List<DeepCopy> list1 = new ArrayList<DeepCopy>(); list1.add(dc); //未使用深度复制 List<DeepCopy> list2 = new ArrayList<DeepCopy>(list1);//这里与使用Collections.copy(dest, src)结果一样 //改变list1中元素的值 for(DeepCopy d1 : list1) { //改变dc1里i的值 d1.i = 2; } //遍历list for(DeepCopy d1 : list1) { System.out.println("list1 : " + d1.i); } //遍历list2 for(DeepCopy d2 : list2) { System.out.println("list2(复制） : " + d2.i); } System.out.println("===========使用深度复制后========="); DeepCopy dc3 = new DeepCopy(); dc3.i = 1;//初始化dc3里i的值 List<DeepCopy> list3 = new ArrayList<DeepCopy>(); list3.add(dc3); List<DeepCopy> list4 = (List<DeepCopy>) deepCopy(list3); for(DeepCopy d : list3) { //改变dc3里i的值 d.i = 2; } for(DeepCopy d3 : list3) { System.out.println("list3 : " + d3.i); } for(DeepCopy d4 : list4) { System.out.println("list4(深度复制）: " + d4.i); } }} |
以上运行结果如下(实测）：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
===========未使用深度复制=========dc1 : 2dc2(引用传递) : 2===========使用深度复制=========dc3 : 2dc4(深度复制) : 1===========未使用深度复制=========list1 : 2list2(复制） : 2===========使用深度复制后=========list3 : 2list4(深度复制）: 1 |
由此可见，当仅仅只是引用传递或者根据对象的值创建新的值，仅能称为“浅复制”，当原对象的属性发生改变时，根据上面方式创建的新对象的属性也会随之改变；而如果采用深度复制，那是真正的copy了一份新的对象，新对象的与原对象不存在任何关联，原对象的属性发生改变不会影响新对象，就如同copy的意义一样
如上，如有不妥，如能指出，非常感谢
希望本文所述对大家java程序设计有所帮助。
原文链接：http://blog.csdn.net/u011437847/article/details/52261191
