java.util.list浅复制和深复制

本文整合量两篇文章，简要概括浅复制和深复制的差异及具体实现场景。感谢两位前辈：

不靠谱的复制解析  ，

深拷贝的对比

使用的一个JavaBean

class Person implements Serializable{  
    private int age;  
    private String name;  
      
    public Person(){};  
    public Person(int age,String name){  
        this.age=age;  
        this.name=name;  
    }  
      
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
      
    public String toString(){  
        return this.name+"-->"+this.age;  
    }  
      
}  

后台打印List集合的一个静态方法

 

 public static <T> void printList(List<T> list){
     System.out.println("---begin---");
     for(T t : list){
         System.out.println(t);
     }
     System.out.println("---end---");
 }

 

 

后台打印数组的一个静态方法

 

 public static <T> void printArray(T[] array){
     System.out.println("---begin---");
     for(T t : array){
         System.out.println(t);
     }
     System.out.println("---end---");
 }

 

 

这是数据源集合，下面将通过各种方法企图来深复制该List集合中的元素

 

 List<Person> srcList=new ArrayList<Person>();
 Person p1=new Person(20,"123");
 Person p2=new Person(21,"ABC");
 Person p3=new Person(22,"abc");
 srcList.add(p1);
 srcList.add(p2);
 srcList.add(p3);

  

1、遍历循环复制

 

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

 printList(destList);
 srcList.get(0).setAge(100);
 printList(destList);

 

 上面的代码在add时候，并没有new Person()操作。因此，在srcList.get(0).setAge(100);破坏源数据时，目标集合destList中元素的输出同样受到了影响，原因是浅复制造成的。

 

 ---begin---
 123-->20
 ABC-->21
 abc-->22
 ---end---
 ---begin---
 123-->100
 ABC-->21
 abc-->22
 ---end---

 

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

 

 List<Person> destList=new ArrayList<Person>(srcList);
 printList(destList);
 srcList.get(0).setAge(100);
 printList(destList);

 

 通过ArrayList的构造方法来复制集合内容，同样是浅复制，在修改了源数据集合后，目标数据集合对应内容也发生了改变。在查阅资料的过程中，看到有人说这种方式 能实现深复制，其实这是不对的。对于某些特殊的元素，程序运行的结果形似深复制，其实还是浅复制。具体一会儿再说。

 

 ---begin---
 123-->20
 ABC-->21
 abc-->22
 ---end---
 ---begin---
 123-->100
 ABC-->21
 abc-->22
 ---end---

 

3、使用list.addAll()方法

 

 List<Person> destList=new ArrayList<Person>();
 destList.addAll(srcList);
 printList(destList);
 srcList.get(0).setAge(100);
 printList(destList);

 

 java.util.list.addAll()方法同样是浅复制

 

 ---begin---
 123-->20
 ABC-->21
 abc-->22
 ---end---
 ---begin---
 123-->100
 ABC-->21
 abc-->22
 ---end---

 

4、使用System.arraycopy()方法

 

 Person[] srcPersons=srcList.toArray(new Person[0]);
 Person[] destPersons=new Person[srcPersons.length];
 System.arraycopy(srcPersons, 0, destPersons, 0, srcPersons.length);
 //destPersons=srcPersons.clone();

 printArray(destPersons);
 srcPersons[0].setAge(100);
 printArray(destPersons);

 List<Person> destList=Arrays.asList(destPersons);
 printList(destList);

这种方式虽然比较变态，但是起码证明了System.arraycopy()方法和clone()是不能对List集合进行深复制的。

 

 

5、使用序列化方法（相对靠谱的方法）

 

 public static <T> List<T> deepCopy(List<T> src) throws IOException, ClassNotFoundException {
     ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
     ObjectOutputStream out = new ObjectOutputStream(byteOut);
     out.writeObject(src);

     ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
     ObjectInputStream in = new ObjectInputStream(byteIn);
     @SuppressWarnings("unchecked")
     List<T> dest = (List<T>) in.readObject();
     return dest;
 }

 

 

 List<Person> destList=deepCopy(srcList);
 printList(destList);
 srcList.get(0).setAge(100);
 printList(destList);

这是比较靠谱的做法，听说是国外某位程序大师提出来的。实际运行的结果也同样是正确的。

 ---begin---
 123-->20
 ABC-->21
 abc-->22
 ---end---
 ---begin---
 123-->20
 ABC-->21
 abc-->22
 ---end---

 

 

其实，上面这些不靠谱List深复制的做法在某些情况是可行的，这也是为什么有些人说这其中的一些做法是可以实现深复制的原因。哪些情况下是可行（本质上可能还是不靠谱）的呢？比如List<String>这样的情况。我上面使用的是List<Person>，它和List<String>的区别就在于Person类和String类的区别，Person类提供了破坏数据的2个setter方法。因此，在浅复制的情况下，源数据被修改破坏之后，使用相同引用指向该数据的目标集合中的对应元素也就发生了相同的变化。

因此，在需求要求必须深复制的情况下，要是使用上面提到的方法，请确保List<T>中的T类对象是不易被外部修改和破坏的。 

针对上述深拷贝效率对比：

ArrayListToDeepClone 

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
 
/**
 * 
 * 深层拷贝测试类
 * @author jt
 *
 */
public class ArrayListToDeepClone {
 
    ArrayList<User> users = new ArrayList<User>();
    ArrayList<User> users2 = null;
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayListToDeepClone clone = new ArrayListToDeepClone();
        clone.test();
        try {
            long begin = System.currentTimeMillis();
            clone.cloneTest();
            // clone.cloneTest2();
            // 通过测试表明 cloneTest 要比 cloneTest2快
            System.out.println(System.currentTimeMillis() - begin);
        } catch (Exception e) {
            e.printStackTrace();
        }
        clone.update();
        clone.print();
    }
 
    @SuppressWarnings("unchecked")
    public void cloneTest2() throws ClassNotFoundException, IOException {
        // users2 = (ArrayList<User>) deepCopy(users);
        users2 = (ArrayList<User>) deepCopy2(users);
    }
 
    public void cloneTest() throws CloneNotSupportedException {
        // 初始化
        // users2 = (ArrayList<User>) users.clone(); // 可以
        users2 = new ArrayList<>(users.size()); // 不可以
 
        // 赋值
        // users2.addAll(users); // 不可以
        for (User user : users) {// 可以
            users2.add((User) user.clone());
        }
    }
 
    public void update() {
        users.get(0).name = "fuck";
    }
 
    public void test() {
        User user1 = new User("kongnan");
        users.add(user1);
    }
 
    public void print() {
        System.out.println(users.get(0).name);
        System.out.println(users2.get(0).name);
    }
 
    // 关键代码 执行序列化和反序列化 进行深度拷贝
    public <T> List<T> deepCopy2(List<T> src) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(src);
 
        ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
        ObjectInputStream in = new ObjectInputStream(byteIn);
        @SuppressWarnings("unchecked")
        List<T> dest = (List<T>) in.readObject();
        return dest;
    }
 
    /**
     * 深层拷贝对象
     * 
     * @param src
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     */
    @SuppressWarnings("rawtypes")
    public List deepCopy(List src) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(src);
 
        ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
        ObjectInputStream in = new ObjectInputStream(byteIn);
        List dest = (List) in.readObject();
        return dest;
    }
}

由效率可见

通过clone再转化进行深复制的效率略高于进行序列化拷贝操作。。

具体实现方法 是使该对象user继承实现 implements Serializable, Cloneable 接口，并将公开public Object clone()方法，返回对象。