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

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()方法

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

2. 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);

测试及结果

1. printList(destList); //打印未改变B之前的A

2. srcList.get(0).setAge(100);//改变B

3. printList(destList); //打印改变B后的A

4.  

5. //打印结果

6. 123-->20

7. ABC-->21

8. abc-->22

9. 123-->100

10. ABC-->21

11. abc-->22

List深拷贝

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

深拷贝的方法

1.使用序列化方法

1. public static <T> List<T> deepCopy(List<T> src) throws IOException, ClassNotFoundException {

2. ByteArrayOutputStream byteOut = new ByteArrayOutputStream();

3. ObjectOutputStream out = new ObjectOutputStream(byteOut);

4. out.writeObject(src);

5.  

6. ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());

7. ObjectInputStream in = new ObjectInputStream(byteIn);

8. @SuppressWarnings("unchecked")

9. List<T> dest = (List<T>) in.readObject();

10. return dest;

11. }

12.  

13. List<Person> destList=deepCopy(srcList); //调用该方法

2.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. }

18. for(int i=0;i<n;i+=){

19. copy.add((A)src.get(i).clone());

20. }

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类对象是不易被外部修改和破坏的。

 

https://blog.csdn.net/justlpf/article/details/80922519