实现list的深拷贝

Posted 2023-04-02

参考技术A 这时，获取source.get(0)的name值，也变成了“CDE”。
为了解决这个问题，使得改变copy中的值，不影响source中的数据，则要进行深拷贝。
即，对A类实现clone()方法：

然后，

就可以进行深拷贝了。

在此，再多描述一下关于Clone的内容。
Java对对象和基本数据类型的处理是不一样的。在Java中用对象作为入口参数的传递则缺省为“引用传递”，也就是说仅仅传递了对象的一个“引用”，这个引用的概念与C语言中的指针引用是一样的。当函数体内部对这个变量进行改变时，实质上就是对这个对象进行直接操作。
除此之外，在任何用“=”向对象变量赋值的时候都是“引用传递”。

一、当Class A的成员变量类型是基本数据类型（外加String类型）时，只要实现如上简单的clone（称影子clone）就可以。但是如果Class A的成员变量是数组或者更复杂类型时，就必须实现深度clone。

此处的A的成员变量String[],影子clone对name数组clone他们的地址，需进行深拷贝。

二、需要注意的是，Class A存在更为复杂的成员变量时，如Vector等存储对象地址的容器时，就必须clone彻底。

list.addAll()是浅拷贝，如何实现list的深拷贝

由于addAll()实现的是浅拷贝，即将 List A>  copy=new ArrayList A>(); List A> src=new Array List A>(); src.add(a); copy.addAll(src); copy.get(0).setName("XXX"); 这时，src.get(0).getName();的值，也变成了XXX。 为了解决这个问题，使得copy里的元素修改，不影响src，则要进行深拷贝。 即，对类A实现clone方法。

1. public class A implements Cloneable    
2.     public String name[];   
3.        
4.     public A()   
5.         name=new String[2];   
6.        
7.   
8.     public Object clone()    
9.         A o = null;   
10.         try    
11.             o = (A) super.clone();   
12.          catch (CloneNotSupportedException e)    
13.             e.printStackTrace();   
14.            
15.         return o;   
16.        
17.  

for(int i=0;i copy.add((A)src.get(i).clone()); 就可以完成深度拷贝了。
在此，再多描述下关于clone的内容。 Java对对象和基本的数据类型的处理是不一样的。在Java中用对象的作为入口参数的传递则缺省为"引用传递"，也就是说仅仅传递了对象的一个"引用"，这个"引用"的概念同C语言中的指针引用是一样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操作。  除了在函数传值的时候是"引用传递"，在任何用"＝"向对象变量赋值的时候都是"引用传递"。
一、当Class A成员变量类型是java的基本类型时（外加String类型）,只要实现如上简单的clone（称影子clone）就可以。但是如果Class A成员变量是数组或复杂类型时，就必须实现深度clone。

1. public class A implements Cloneable    
2.     public String name[];   
3.        
4.     public A()   
5.         name=new String[2];   
6.        
7.   
8.     public Object clone()    
9.         A o = null;   
10.         try    
11.             o = (A) super.clone();   
12.          catch (CloneNotSupportedException e)    
13.             e.printStackTrace();   
14.            
15.         return o;   
16.        
17.  

此处的A的变量是String[]，影子clone对name数组只是clone他们的地址。需进行深拷贝。

1. public Object clone()    
2.         A o = null;   
3.         try    
4.             o = (A) super.clone();   
5.             o.name=(String[])name.clone();//其实也很简单^_^   
6.          catch (CloneNotSupportedException e)    
7.             e.printStackTrace();   
8.            
9.         return o;   
10.      

二、需要注意的是Class A存在更为复杂的成员变量时，如Vector等存储对象地址的容器时，就必须clone彻底。

1. public class A implements Cloneable    
2.     public String name[];   
3.     public Vector B> claB;
4.        
5.     public A()   
6.         name=new String[2];   
7.         claB=new Vector B>();
8.        
9.   
10.     public Object clone()    
11.         A o = null;   
12.         try    
13.             o = (A) super.clone();   
14.             o.name==(String[])name.clone();//深度clone   
15.             o.claB=new Vector B>();//将clone进行到底   
16.             for(int i=0;i < claB.size() ; i ++ )
17.                 o.claB.add((B)claB.get(i).clone()); //当然Class B也要实现相应clone方法   
18.                
19.          catch (CloneNotSupportedException e)    
20.             e.printStackTrace();   
21.            
22.                 return o;   
23.        

转自：http://lovelace.iteye.com/blog/182772