Java List 深度复制方法

前言

之前探讨过Java数组的深复制问题，现在来说说<一些不靠谱的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  void printList(List list){  
    System.out.println("---begin---");  
    for(T t : list){  
        System.out.println(t);  
    }  
    System.out.println("---end---");  
}  

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

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

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

List srcList=new ArrayList();  
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、遍历循环复制

ayList(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 destList=new ArrayList(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 destList=new ArrayList();  
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 destList=Arrays.asList(destPersons);  
printList(destList);  

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

深度复制

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

public static  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);  
    @SuppressWarnings("unchecked")  
    List dest = (List) in.readObject();  
    return dest;  
}  

List 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这样的情况。我上面使用的是List，它和List的区别就在于Person类和String类的区别，Person类提供了破坏数据的2个setter方法。因此，在浅复制的情况下，源数据被修改破坏之后，使用相同引用指向该数据的目标集合中的对应元素也就发生了相同的变化。
因此，在需求要求必须深复制的情况下，要是使用上面提到的方法，请确保List中的T类对象是不易被外部修改和破坏的。

另一个问题

上面实体类是实现了Serializable接口，那么使用上面方法可以实现深度复制，但是如果是实现了Android中的Parcelable接口，上面方法就不行了！
那么一个比较统一的且可以实现深度复制的方法就是：将我们的List转换为json，再把json转回List！
这里我们使用Gson来转换：

public static  ArrayList jsonToArrayList(String json, Class clazz) {
        Type type = new TypeToken>() {
        }.getType();
        ArrayList jsonObjects = new Gson().fromJson(json, type);

        ArrayList arrayList = new ArrayList<>();
        for (JsonObject jsonObject : jsonObjects) {
            arrayList.add(new Gson().fromJson(jsonObject, clazz));
        }
        return arrayList;
    }

使用的时候：

Gson gson = new Gson();
String jsonTran = gson.toJson(sourceList);
ArrayList deepCloneList= GsonUtil.jsonToArrayList(jsonTran, T.class);

这样deepCloneList就是源list深度复制的list了！且修改源list，并不影响复制之后的list！