List 复制之 浅拷贝与深拷贝

List浅拷贝

众所周知，list本质上是数组，而数组的是以地址的形式进行存储。 
（listA中有一个元素Object）如上图将list A浅拷贝给list B，由于进行的是浅拷贝，所以直接将A的内容复制给了B，虽然listA和listB所在的地址不一样，但是两个list存储的对象仍然是同一个Object（因为把listA复制到listB时，浅拷贝不是复制Object到B，而是把Object的引用复制到B，所以两个地址仍指向同一个Object），导致改变在listA中改变Object的值时，listB中的也会改变。

几种浅拷贝

1、遍历循环复制

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

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

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

3、使用list.addAll()方法

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

4、使用System.arraycopy()方法

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

测试及结果

printList(destList); //打印未改变B之前的A 
srcList.get(0).setAge(100);//改变B  
printList(destList); //打印改变B后的A

//打印结果
123-->20  
ABC-->21  
abc-->22  
123-->100  
ABC-->21  
abc-->22  

List深拷贝

如图，深拷贝就是将A复制给B的同时，再将地址A存储的对象拷贝传递到地址B的引用。ListA与ListB内容一致，但是由于地址中引用的对象不同，所以改变listA中的Object不会影响listB中的Object，因为存储的对象已经不一样，只是两个对象的值一样，相互不受影响。

深拷贝的方法

1.使用序列化方法（JAVA版）

// 这里需要深拷贝的类（T）需要继承 Serializable 接口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);  //调用该方法

C#版：

/// <summary>
/// 深拷贝（通过反射）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static T DeepCopyByReflect<T>(T obj)
{
    //如果是字符串或值类型则直接返回
    if (obj == null || obj is string || obj.GetType().IsValueType) return obj;
    object retval = Activator.CreateInstance(obj.GetType());
    FieldInfo[] fields = obj.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
    foreach (FieldInfo field in fields)
    {
        try {
            field.SetValue(retval, DeepCopyByReflect(field.GetValue(obj))); 
        }
        catch { }
    }
    return (T)retval;
}

2.clone方法

public class A implements Cloneable {   
    public String name[];   

    public A(){   
        name=new String[2];   
    }   

    public Object clone() {   
        A o = null;   
        try {   
            o = (A) super.clone();   
        } catch (CloneNotSupportedException e) {   
            e.printStackTrace();   
        }   
        return o;   
    }   
}  
for(int i=0;i<n;i+=){
copy.add((A)src.get(i).clone());
}

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

测试及结果

printList(destList); //打印未改变B之前的A 
srcList.get(0).setAge(100);//改变B  
printList(destList); //打印改变B后的A

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

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

参考：http://blog.csdn.net/demonliuhui/article/details/54572908