java中ArrayList深拷贝有关问题

基本思路就是将要深拷贝的对象实现Serializable接口。

浅拷贝：被复制对象的任何变量都含有和原来的对象相同的值，而任何的对其他对象的引用仍然指向原来的对象。对拷贝后的引用的修改，还能影响原来的对象。

深拷贝：把要复制的对象所引用的对象都复制了一遍，对现在对象的修改不会影响原有的对象。

-------------------------------------------------------------------------------------

//浅拷贝与深拷贝
//浅拷贝:被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
//换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
//深拷贝：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。
//那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。
//换言之，深复制把要复制的对象所引用的对象都复制了一遍。
//1、直接赋值（字符串外都属于浅拷贝）
//2、使用构造函数（深拷贝）
//3、使用clone()方法（深拷贝）

Java代码  

1. import java.io.Serializable;  
2. public class Person implements Serializable{  
3.     private static final long serialVersionUID = -7622835197591599128L;  
4.     private int age;  
5.     private String name;  
6.       
7.     public Person(){};  
8.     public Person(String name,int age){  
9.         this.name=name;  
10.         this.age=age;  
11.     }  
12.       
13.     public int getAge() {  
14.         return age;  
15.     }  
16.     public void setAge(int age) {  
17.         this.age = age;  
18.     }  
19.     public String getName() {  
20.         return name;  
21.     }  
22.     public void setName(String name) {  
23.         this.name = name;  
24.     }  
25.       
26.     public String toString(){  
27.         return this.name+"-->"+this.age;  
28.     }  
29.       
30. }  

Java代码  

1. import java.io.ByteArrayInputStream;  
2. import java.io.ByteArrayOutputStream;  
3. import java.io.IOException;  
4. import java.io.ObjectInputStream;  
5. import java.io.ObjectOutputStream;  
6. import java.util.ArrayList;  
7. import java.util.List;  
8.   
9.   
10. public class Test {  
11.   
12.     public static <T> void printList(List<T> list){  
13.         System.out.println("---begin---");  
14.         for(T t : list){  
15.             System.out.println(t);  
16.         }  
17.         System.out.println("---end---");  
18.     }  
19.       
20.     public static <T> void printArray(T[] array){  
21.         System.out.println("---begin---");  
22.         for(T t : array){  
23.             System.out.println(t);  
24.         }  
25.         System.out.println("---end---");  
26.     }  
27.       
28.     //关键代码 执行序列化和反序列化  进行深度拷贝  
29.     public static <T> List<T> deepCopy(List<T> src) throws IOException, ClassNotFoundException {  
30.         ByteArrayOutputStream byteOut = new ByteArrayOutputStream();  
31.         ObjectOutputStream out = new ObjectOutputStream(byteOut);  
32.         out.writeObject(src);  
33.   
34.         ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());  
35.         ObjectInputStream in = new ObjectInputStream(byteIn);  
36.         @SuppressWarnings("unchecked")  
37.         List<T> dest = (List<T>) in.readObject();  
38.         return dest;  
39.     }  
40.       
41.        //关键代码 执行序列化和反序列化  进行深度拷贝，写法不同而已，作用一样  
42.        //个人习惯 怎么喜欢怎么来！  
43.     public List deepCopy(List src) throws IOException, ClassNotFoundException{             
44.         ByteArrayOutputStream byteOut = new ByteArrayOutputStream();             
45.         ObjectOutputStream out = new ObjectOutputStream(byteOut);             
46.         out.writeObject(src);                    
47.         ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());             
48.         ObjectInputStream in =new ObjectInputStream(byteIn);             
49.         List dest = (List)in.readObject();             
50.         return dest;         
51.     }  
52.       
53.     public static void main(String[] args) throws IOException, ClassNotFoundException {  
54.         List<Person> srcList=new ArrayList<Person>();  
55.         Person p1=new Person("123",20);  
56.         Person p2=new Person("ABC",21);  
57.         Person p3=new Person("abc",22);  
58.         srcList.add(p1);  
59.         srcList.add(p2);  
60.         srcList.add(p3);  
61.   
62.         List<Person> destList=deepCopy(srcList);  
63.         printList(destList);  
64.         srcList.get(0).setAge(100);  
65.         System.out.println(srcList.get(0) == destList.get(0));  
66.         printList(destList);  
67.         printList(srcList);  
68.           
69.                   
70.                 //这种复制也是浅拷贝，不能达到要求  
71.         //Collections.copy(List des,List src)  
72. //      List<Person> destList=new ArrayList<Person>( Arrays.asList(new Person[srcList.size()]));  
73. //      //List<Person> destList=new ArrayList<Person>(srcList.size());  
74. //      //List iss = new ArrayList(Arrays.asList(new Object[srcList.size()]));  
75. //        
76. //      //System.out.println(destList.size());  
77. //      Collections.copy(destList,srcList );  
78. //        
79. //      srcList.get(0).setAge(100);  
80. //      System.out.println(srcList.get(0) == destList.get(0));  
81. //      printList(destList);  
82. //      printList(srcList);  
83.           
84.     }  
85.   
86. }  

本文引用：
http://will-turner.iteye.com/blog/1478194