关于java对象复制clone 给一个对象赋值会随原来的对象变化

Dear 丶 2022-08-21 04:45 16阅读 0赞

[http://zhangyulong.iteye.com/blog/1462279][http_zhangyulong.iteye.com_blog_1462279]

Java代码   [![收藏代码][icon_star.png]][icon_star.png 1]

1.  问题如下  
2.    
3.  **public** **static** **void** main(String\[\] args)\{  
4.          User c1=**new** User();  
5.          c1.setId(1);  
6.            
7.          User c2=**new** User();  
8.          c2=c1;  
9.          System.out.println(c2.getId());  
10.         c1.setId(2);  
11.         System.out.println(c2.getId());  
12.           
13.         String s1="s1";  
14.         String s2="s2";  
15.         System.out.println(s2);  
16.         s2=s1;  
17.         s1="sss";  
18.         System.out.println(s2);  
19.           
20.           
21.     \}   
22.   
23. 输出如下  
24. 1  
25. 2  
26. s2  
27. s1  
28.   
29.   
30.   
31.   
32.   
33.   
34.   
35.   
36. 关于java对象复制（转）  
37.    
38. 关于java对象复制  
39. 我们在编码过程经常会碰到将一个对象传递给另一个对象，java中对于基本型变量  
40. 采用的是值传递，而对于对象比如bean传递时采用的是应用传递也就是地址传递，  
41. 而很多时候对于对象传递我们也希望能够象值传递一样，使得传递之前和之后有  
42. 不同的内存地址，在这种情况下我们一般采用以下两种情况。  
43.   
44. 1 对象克隆  
45. 什么是"clone"？  
46.   
47.   
48. 在实际编程过程中，我们常常要遇到这种情况：有一个对象A，在某一时刻A中已经包含了一些有效值，此时可能会需要一个和A完全相同新对象B，并且此后对B任何改动都不会影响到A中的值，也就是说，A与B是两个独立的对象，但B的初始值是由A对象确定的。在Java语言中，用简单的赋值语句是不能满足这种需求的。要满足这种需求虽然有很多途径，但实现clone（）方法是其中最简单，也是最高效的手段。  
49.   
50. Java的所有类都默认继承java.lang.Object类，在java.lang.Object类中有一个方法clone()。JDK API的说明文档解释这个方法将返回Object对象的一个拷贝。要说明的有两点：一是拷贝对象返回的是一个新对象，而不是一个引用。二是拷贝对象与用**new**操作符返回的新对象的区别就是这个拷贝已经包含了一些原来对象的信息，而不是对象的初始信息。  
51.   
52. 怎样应用clone()方法？  
53.   
54.   
55. 一个很典型的调用clone()代码如下：  
56.   
57. **class** CloneClass **implements** Cloneable\{  
58.     **public** **int** aInt;  
59.     **public** Object clone()\{  
60.         CloneClass o = **null**;  
61.         **try**\{  
62.             o = (CloneClass)**super**.clone();  
63.         \}**catch**(CloneNotSupportedException e)\{  
64.             e.printStackTrace();  
65.         \}  
66.         **return** o;  
67.     \}  
68. ｝  
69.   
70.   
71.   
72.   
73. 有三个值得注意的地方，一是希望能实现clone功能的CloneClass类实现了Cloneable接口，这个接口属于java.lang包，java.lang包已经被缺省的导入类中，所以不需要写成java.lang.Cloneable。另一个值得请注意的是重载了clone()方法。最后在clone()方法中调用了**super**.clone()，这也意味着无论clone类的继承结构是什么样的，**super**.clone()直接或间接调用了java.lang.Object类的clone()方法。下面再详细的解释一下这几点。  
74.   
75. 应该说第三点是最重要的，仔细观察一下Object类的clone()一个**native**方法，**native**方法的效率一般来说都是远高于java中的非**native**方法。这也解释了为什么要用Object中clone()方法而不是先**new**一个类，然后把原始对象中的信息赋到新对象中，虽然这也实现了clone功能。对于第二点，也要观察Object类中的clone()还是一个**protected**属性的方法。这也意味着如果要应用clone()方法，必须继承Object类，在Java中所有的类是缺省继承Object类的，也就不用关心这点了。然后重载clone()方法。还有一点要考虑的是为了让其它类能调用这个clone类的clone()方法，重载之后要把clone()方法的属性设置为**public**。  
76.   
77. 那么clone类为什么还要实现Cloneable接口呢？稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了**super**.Clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常。  
78.   
79. 什么是影子clone？  
80.   
81.   
82. 下面的例子包含三个类UnCloneA，CloneB，CloneMain。CloneB类包含了一个UnCloneA的实例和一个**int**类型变量，并且重载clone()方法。CloneMain类初始化UnCloneA类的一个实例b1，然后调用clone()方法生成了一个b1的拷贝b2。最后考察一下b1和b2的输出：  
83.   
84. **package** clone;  
85. **class** UnCloneA \{  
86.     **private** **int** i;  
87.     **public** UnCloneA(**int** ii) \{ i = ii; \}  
88.     **public** **void** doubleValue() \{ i \*= 2; \}  
89.     **public** String toString() \{  
90.         **return** Integer.toString(i);  
91.     \}  
92. \}  
93. **class** CloneB **implements** Cloneable\{  
94.     **public** **int** aInt;  
95.     **public** UnCloneA unCA = **new** UnCloneA(111);  
96.     **public** Object clone()\{  
97.         CloneB o = **null**;  
98.         **try**\{  
99.             o = (CloneB)**super**.clone();  
100.         \}**catch**(CloneNotSupportedException e)\{  
101.             e.printStackTrace();  
102.         \}  
103.         **return** o;  
104.     \}  
105. \}  
106. **public** **class** CloneMain \{  
107.     **public** **static** **void** main(String\[\] a)\{  
108.         CloneB b1 = **new** CloneB();  
109.         b1.aInt = 11;  
110.         System.out.println("before clone,b1.aInt = "\+ b1.aInt);  
111.         System.out.println("before clone,b1.unCA = "\+ b1.unCA);  
112.                   
113.         CloneB b2 = (CloneB)b1.clone();  
114.         b2.aInt = 22;  
115.         b2.unCA.doubleValue();  
116.         System.out.println("=================================");  
117.         System.out.println("after clone,b1.aInt = "\+ b1.aInt);  
118.         System.out.println("after clone,b1.unCA = "\+ b1.unCA);  
119.         System.out.println("=================================");  
120.         System.out.println("after clone,b2.aInt = "\+ b2.aInt);  
121.         System.out.println("after clone,b2.unCA = "\+ b2.unCA);  
122.     \}  
123. \}  
124.   
125.   
126. /\*\* RUN RESULT: 
127. before clone,b1.aInt = 11 
128. before clone,b1.unCA = 111 
129. ================================= 
130. after clone,b1.aInt = 11 
131. after clone,b1.unCA = 222 
132. ================================= 
133. after clone,b2.aInt = 22 
134. after clone,b2.unCA = 222 
135. \*/  
136.   
137.   
138.   
139.   
140.   
141. 输出的结果说明**int**类型的变量aInt和UnCloneA的实例对象unCA的clone结果不一致，**int**类型是真正的被clone了，因为改变了b2中的aInt变量，对b1的aInt没有产生影响，也就是说，b2.aInt与b1.aInt已经占据了不同的内存空间，b2.aInt是b1.aInt的一个真正拷贝。相反，对b2.unCA的改变同时改变了b1.unCA，很明显，b2.unCA和b1.unCA是仅仅指向同一个对象的不同引用！从中可以看出，调用Object类中clone()方法产生的效果是：先在内存中开辟一块和原始对象一样的空间，然后原样拷贝原始对象中的内容。对基本数据类型，这样的操作是没有问题的，但对非基本类型变量，我们知道它们保存的仅仅是对象的引用，这也导致clone后的非基本类型变量和原始对象中相应的变量指向的是同一个对象。  
142.   
143. 大多时候，这种clone的结果往往不是我们所希望的结果，这种clone也被称为"影子clone"。要想让b2.unCA指向与b2.unCA不同的对象，而且b2.unCA中还要包含b1.unCA中的信息作为初始信息，就要实现深度clone。  
144.   
145. 怎么进行深度clone？  
146.   
147.   
148. 把上面的例子改成深度clone很简单，需要两个改变：一是让UnCloneA类也实现和CloneB类一样的clone功能（实现Cloneable接口，重载clone()方法）。二是在CloneB的clone()方法中加入一句o.unCA = (UnCloneA)unCA.clone();  
149.   
150. 程序如下：  
151.   
152. **package** clone.ext;  
153. **class** UnCloneA **implements** Cloneable\{  
154.     **private** **int** i;  
155.     **public** UnCloneA(**int** ii) \{ i = ii; \}  
156.     **public** **void** doubleValue() \{ i \*= 2; \}  
157.     **public** String toString() \{  
158.         **return** Integer.toString(i);  
159.     \}  
160.     **public** Object clone()\{  
161.         UnCloneA o = **null**;  
162.         **try**\{  
163.             o = (UnCloneA)**super**.clone();  
164.         \}**catch**(CloneNotSupportedException e)\{  
165.             e.printStackTrace();  
166.         \}  
167.         **return** o;  
168.     \}  
169. \}  
170. **class** CloneB **implements** Cloneable\{  
171.     **public** **int** aInt;  
172.     **public** UnCloneA unCA = **new** UnCloneA(111);  
173.     **public** Object clone()\{  
174.         CloneB o = **null**;  
175.         **try**\{  
176.             o = (CloneB)**super**.clone();  
177.         \}**catch**(CloneNotSupportedException e)\{  
178.             e.printStackTrace();  
179.         \}  
180.         o.unCA = (UnCloneA)unCA.clone();  
181.         **return** o;  
182.     \}  
183. \}  
184. **public** **class** CloneMain \{  
185.     **public** **static** **void** main(String\[\] a)\{  
186.         CloneB b1 = **new** CloneB();  
187.         b1.aInt = 11;  
188.         System.out.println("before clone,b1.aInt = "\+ b1.aInt);  
189.         System.out.println("before clone,b1.unCA = "\+ b1.unCA);  
190.                   
191.         CloneB b2 = (CloneB)b1.clone();  
192.         b2.aInt = 22;  
193.         b2.unCA.doubleValue();  
194.         System.out.println("=================================");  
195.         System.out.println("after clone,b1.aInt = "\+ b1.aInt);  
196.         System.out.println("after clone,b1.unCA = "\+ b1.unCA);  
197.         System.out.println("=================================");  
198.         System.out.println("after clone,b2.aInt = "\+ b2.aInt);  
199.         System.out.println("after clone,b2.unCA = "\+ b2.unCA);  
200.     \}  
201. \}  
202.   
203. /\*\* RUN RESULT: 
204. before clone,b1.aInt = 11 
205. before clone,b1.unCA = 111 
206. ================================= 
207. after clone,b1.aInt = 11 
208. after clone,b1.unCA = 111 
209. ================================= 
210. after clone,b2.aInt = 22 
211. after clone,b2.unCA = 222 
212. \*/  
213.   
214.   
215.   
216.   
217.   
218. 可以看出，现在b2.unCA的改变对b1.unCA没有产生影响。此时b1.unCA与b2.unCA指向了两个不同的UnCloneA实例，而且在CloneB b2 = (CloneB)b1.clone();调用的那一刻b1和b2拥有相同的值，在这里，b1.i = b2.i = 11。  
219.   
220. 要知道不是所有的类都能实现深度clone的。例如，如果把上面的CloneB类中的UnCloneA类型变量改成StringBuffer类型，看一下JDK API中关于StringBuffer的说明，StringBuffer没有重载clone()方法，更为严重的是StringBuffer还是一个**final**类，这也是说我们也不能用继承的办法间接实现StringBuffer的clone。如果一个类中包含有StringBuffer类型对象或和StringBuffer相似类的对象，我们有两种选择：要么只能实现影子clone，要么就在类的clone()方法中加一句（假设是SringBuffer对象，而且变量名仍是unCA）： o.unCA = **new** StringBuffer(unCA.toString()); //原来的是：o.unCA = (UnCloneA)unCA.clone();  
221.   
222. 还要知道的是除了基本数据类型能自动实现深度clone以外，String对象是一个例外，它clone后的表现好象也实现了深度clone，虽然这只是一个假象，但却大大方便了我们的编程。  
223.   
224. 通过以上我们可以看出在某些情况下，我们可以利用clone方法来实现对象只见的复制，但对于比较复杂的对象（比如对象中包含其他对象，其他对象又包含别的对象.....）这样我们必须进行层层深度clone，每个对象需要实现cloneable接口，比较麻烦，那就继续学习下一个序列化方法。  
225.   
226. 2 对象序列化  
227.   
228. 所谓对象序列化就是将对象的状态转换成字节流，以后可以通过这些值再生成相同状态的对象。这个过程也可以通过网络实现，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。是不是很神奇。  
229.   
230. 也许你会说，只了解一点点，但从来没有接触过，其实未必如此。RMI、Socket、JMS、EJB你总该用过一种吧，彼此为什么能够传递Java对象，当然都是对象序列化机制的功劳。  
231.   
232. 第一次使用Java的对象序列化是做某项目，当时要求把几棵非常复杂的树(JTree)及相应的数据保存下来（就是我们常用的保存功能），以便下次运行程序时可以继续上次的操作。  
233.   
234. 那时XML技术在网上非常的热，而且功能也强大，再加上树的结构本来就和XML存储数据的格式很像。作为一项对新技术比较有兴趣的我当然很想尝试一下。不过经过仔细分析，发现如果采用XML保存数据，后果真是难以想象：哪棵树的哪个节点被展开、展开到第几级、节点当前的属性是什么。真是不知该用A、B、C还是用1、2、3来表示。  
235.   
236. 还好，发现了Java的对象序列化机制，问题迎刃而解，只需简单的将每棵树的根节点序列化保存到硬盘上，下次再通过反序列化后的根节点就可以轻松的构造出和原来一模一样的树来。  
237.   
238. 其实保存数据，尤其是复杂数据的保存正是对象序列化的典型应用。最近另一个项目就遇到了需要对非常复杂的数据进行存取，通过使用对象的序列化，问题同样化难为简。  
239.   
240. 对象的序列化还有另一个容易被大家忽略的功能就是对象复制（Clone），Java中通过Clone机制可以复制大部分的对象，但是众所周知，Clone有深层Clone和浅层Clone,如果你的对象非常非常复杂，假设有个100层的Collection（夸张了点），如果你想实现深层Clone，真是不敢想象，如果使用序列化，不会超过10行代码就可以解决。  
241.   
242. 还有就是Swing组件，如果你有两个很象很象（或是一模一样）的比较难以构造的Swing组件，你该怎么办，也许你想到了Clone，但是偏偏Java的Swing组件没有提供Clone方法。别急，使用序列化，6行代码搞定：  
243.   
244. ByteArrayOutputStream  
245. byteOut = **new** ByteArrayOutputStream();   
246. ObjectOutputStream out  
247. = **new** ObjectOutputStream(byteOut);   
248. out.writeObject(combo);   
249.   
250. ByteArrayInputStream byteIn = **new** ByteArrayInputStream(byteOut.toByteArray());   
251. ObjectInputStream in  
252. =**new** ObjectInputStream(byteIn);   
253. JComboBox comb2 = (JComboBox)in.readObject();  
254.   
255.   
256. 虽然Java的序列化非常简单、强大，但是要用好，还有很多地方需要注意。比如曾经序列化了一个对象，可由于某种原因，该类做了一点点改动，然后重新被编译，那么这时反序列化刚才的对象，将会出现异常。   
257.   
258. 你可以通过添加serialVersionUID属性来解决这个问题。如果你的类是个单态（Singleton）类，是否允许用户通过序列化机制复制该类，如果不允许你需要谨慎对待该类的实现。   
259.   
260.   
261.     /\*\* 
262.      \* Clone Object 
263.      \* @param obj 
264.      \* @return 
265.      \* @throws Exception 
266.      \*/  
267.     **private** Object cloneObject(Object obj) **throws** Exception\{  
268.         ByteArrayOutputStream byteOut = **new** ByteArrayOutputStream();   
269.         ObjectOutputStream out = **new** ObjectOutputStream(byteOut);   
270.         out.writeObject(obj);   
271.           
272.         ByteArrayInputStream byteIn = **new** ByteArrayInputStream(byteOut.toByteArray());   
273.         ObjectInputStream in =**new** ObjectInputStream(byteIn);  
274.           
275.         **return** in.readObject();  
276.     \}

[http_zhangyulong.iteye.com_blog_1462279]: http://zhangyulong.iteye.com/blog/1462279
[icon_star.png]: http://zhangyulong.iteye.com/images/icon_star.png
[icon_star.png 1]: /images/20220731/9754a7d4e55747c48a34b8bc26b0c8e0.png