java List 复制：浅拷贝与深拷贝

Java 的拷贝可以分为三种：浅拷贝 (Shallow Copy)、深拷贝 (Deep Copy)、延迟拷贝 (Lazy Copy)。

在 java 中除了基本数据类型之外（int,long,short 等），还存在引用数据类型，例如 String 以及对象实例。

对于基本数据类型，实际上是拷贝它的值，而对于引用数据类型，拷贝的就是它的引用，并没有创建一个新的对象，即没有分配新的内存空间。这样的拷贝就称作浅拷贝。

深拷贝就是在引用类型进行拷贝时，创建了新的对象，即分配了新的内存空间给拷贝对象。下面就来具体看看浅拷贝和深拷贝的区别 

List 浅拷贝

众所周知，list 本质上是数组，而数组的是以地址的形式进行存储。
如上图将 list A 浅拷贝给 list B，由于进行的是浅拷贝，所以直接将 A 的内容复制给了 B，java 中相同内容的数组指向同一地址，即进行浅拷贝后 A 与 B 指向同一地址。造成的后果就是，改变 B 的同时也会改变 A，因为改变 B 就是改变 B 所指向地址的内容，由于 A 也指向同一地址，所以 A 与 B 一起改变。

几种浅拷贝

1、遍历循环复制

1 List<Person> destList = new ArrayList<Person>(srcList.size());  
2 for(Person p : srcList){  
3     destList.add(p);  
4 }

2、使用 List 实现类的构造方法

List<Person> destList = new ArrayList<Person>(srcList);

3、使用 list.addAll () 方法

List<Person> destList = new ArrayList<Person>();  
destList.addAll(srcList);  

4、使用 System.arraycopy () 方法

1 Person[] srcPersons=srcList.toArray(new Person[0]); 
2 Person[] destPersons=new Person[srcPersons.length]; 
3 System.arraycopy(srcPersons, 0, destPersons, 0, srcPersons.length);

5、使用 Stream 的方式 copy

List<Person> destList = srcList.stream().collect(Collectors.toList());

测试及结果

 1 printList(destList); //打印未改变B之前的A 
 2 srcList.get(0).setAge(100);//改变B  
 3 printList(destList); //打印改变B后的A
 4 //打印结果 
 5 123-->20  
 6 ABC-->21  
 7 abc-->22  
 8 123-->100  
 9 ABC-->21  
10 abc-->22

List 深拷贝

如图，深拷贝就是将 A 复制给 B 的同时，给 B 创建新的地址，再将地址 A 的内容传递到地址 B。ListA 与 ListB 内容一致，但是由于所指向的地址不同，所以改变相互不受影响。

深拷贝的方法

1. 使用序列化方法

 1   /**
 2      * 对集合进行深拷贝
 3      * 注意需要岁泛型类进行序列化（实现serializable）
 4      *
 5      * @param src
 6      * @param <T>
 7      * @return
 8      * @throws IOException
 9      * @throws ClassNotFoundException
10      */
11     public static <T> List<T> deepCopy(List<T> src) {
12         try (ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
13              ObjectOutputStream outputStream = new ObjectOutputStream(byteOut);
14         ) {
15             outputStream.writeObject(src);
16             try (ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
17                  ObjectInputStream inputStream = new ObjectInputStream(byteIn);
18             ) {
19                 return (List<T>) inputStream.readObject();
20             }
21         } catch (Exception e) {
22             ThrowableUtils.getString(e);
23         }
24         return Collections.emptyList();
25     }

2.clone 方法

 1 public class A implements Cloneable { 
 2     public String name[]; 
 3     public A(){ name=new String[2]; } 
 4     public Object clone() { 
 5         A o = null; 
 6         try { 
 7             o = (A) super.clone(); 
 8         } catch (CloneNotSupportedException e) {        
 9             e.printStackTrace(); 
10         } return o; 
11     } 
12 } 
13 
14 for(int i=0;i<n;i+=){ 
15     copy.add((A)src.get(i).clone()); 
16 }

Java 对对象和基本的数据类型的处理是不一样的。在 Java 中用对象的作为入口参数的传递则缺省为” 引用传递”，也就是说仅仅传递了对象的一个” 引用”，这个” 引用” 的概念同 C 语言中的指针引用是一样的。当函数体内部对输入变量改变时，实质上就是在对这个对象的直接操作。 除了在函数传值的时候是” 引用传递”，在任何用”＝” 向对象变量赋值的时候都是” 引用传递”。

测试及结果

 1 printList(destList); //打印未改变B之前的A 
 2 srcList.get(0).setAge(100);//改变B  
 3 printList(destList); //打印改变B后的A 
 4 
 5 123-->20  
 6 ABC-->21  
 7 abc-->22  
 8 123-->20  
 9 ABC-->21  
10 abc-->22

在浅复制的情况下，源数据被修改破坏之后，使用相同引用指向该数据的目标集合中的对应元素也就发生了相同的变化。因此，在需求要求必须深复制的情况下，要是使用上面提到的方法，请确保 List 中的 T 类对象是不易被外部修改和破坏的。

原文链接：java List复制：浅拷贝与深拷贝 - osc_012r8cm6的个人空间 - OSCHINA - 中文开源技术交流社区