Java Generic Deep Copy

/** Basic usage of the utility.
 * @throws Exception */
public void testBasicUsage() throws Exception {
    DeepCopyUtil deepCopyUtil = new DeepCopyUtil(); // create deep copies of objects.
    
    // create an object
    CustomClass customObject = new CustomClass();
    
    // create a copy of the object
    CustomClass copy = deepCopyUtil.deepCopy(customObject);
    
    assertFalse(customObject == copy);
}

各種類類型

這個例子演示了簡單類的深度拷貝。

/** Test that deep copy correctly copies basic object types.
 * @throws Exception */
public void testVariousTypes() throws Exception {
    DeepCopyUtil deepCopyUtil = new DeepCopyUtil(); // used to create deep copies of objects.
    Calendar cal = Calendar.getInstance();
    int intArray[] = {1,2,3};
    Integer integerArray[] = new Integer[]{1,2,3};
    List<String> stringListFromArray = Arrays.asList(new String[]{"one", "two"});
    List<String> normalList = new ArrayList<String>();
    normalList.add("weeeeee");

    Calendar calCopy = deepCopyUtil.deepCopy(cal); // create deep copies of objects.
    int intArrayCopy[] = deepCopyUtil.deepCopy(intArray);
    Integer integerArrayCopy[] = deepCopyUtil.deepCopy(integerArray);
    List<String> stringListFromArrayCopy = deepCopyUtil.deepCopy(stringListFromArray);
    List<String> normalListCopy = deepCopyUtil.deepCopy(normalList);
    
    assertFalse(cal == calCopy); // assure instances are different.
    assertFalse(intArray == intArrayCopy);
    assertFalse(integerArray == integerArrayCopy);
    assertFalse(stringListFromArray == stringListFromArrayCopy);
    assertFalse(normalList == normalListCopy);
    
    assertTrue(cal.equals(calCopy)); // assure values are the same.
    for (int i = 0; i < intArray.length; i++) {
        assertTrue(intArray[i] == intArrayCopy[i]); // int's use ==
    }
    for (int i = 0; i < integerArray.length; i++) {
        assertFalse(integerArray[i] == integerArrayCopy[i]); // Integers use .equals
        assertTrue(integerArray[i].equals(integerArrayCopy[i]));
    }
    for (int i = 0; i < stringListFromArray.size(); i++) { // instances are different, values are equal.
        assertFalse(stringListFromArray.get(i) == stringListFromArrayCopy.get(i));
        assertTrue(stringListFromArray.get(i).equals(stringListFromArrayCopy.get(i)));
    }
    for (int i = 0; i < normalList.size(); i++) { // instances are different, values are equal.
        assertFalse(normalList.get(i) == normalListCopy.get(i));
        assertTrue(normalList.get(i).equals(normalListCopy.get(i)));
    }
    
    assertTrue(cal.getClass() == calCopy.getClass()); // assure class types are the same.
    assertTrue(intArray.getClass() == intArrayCopy.getClass());
    assertTrue(integerArray.getClass() == integerArrayCopy.getClass());
    assertTrue(stringListFromArray.getClass() == stringListFromArrayCopy.getClass());
    assertTrue(normalList.getClass() == normalListCopy.getClass());
}

大型 LinkedList

深度拷貝超過包含100,000個對象的LinkedList

/** Assure that a LinkedList of 100,000 elements can be deep copied. <br/>
 * Add -Xms512m and -Xmx1536m to the JVM args to see this work with 1,000,000.
 * @throws Exception */
public void testLinkedList() throws Exception {
    DeepCopyUtil deepCopyUtil = new DeepCopyUtil(); // used to create deep copies of objects.
    List<Integer> lst = new LinkedList<Integer>(); // Create a linked list of Integers.
    for (int i = 0; i < 100000; i++) {
        lst.add(i);
    }
    
    List<Integer> copyOfList = deepCopyUtil.deepCopy(lst); // create a deep copy
    
    assertTrue(copyOfList.size() == lst.size()); // test that the lists are the same size.
    assertFalse(copyOfList == lst); // test that the lists are not the same lists.
    
    // create some iterators instead of using list.get(), because we're using a LinkedList
    // and that would be slow.
    Iterator<Integer> origIt = lst.iterator();
    Iterator<Integer> copyIt = copyOfList.iterator();
    Integer origInt, copyInt;

    while (origIt.hasNext()) { // compare each of the items in both lists
        origInt = origIt.next();
        copyInt = copyIt.next();

        assertFalse(origInt == copyInt); // the lists should not be the same instance.
        assertTrue(origInt.equals(copyInt)); // the inner values should be the same.
    }
}

循環引用

深度拷貝一個循環引用的類。這個類包含很多對自己的引用並且仍然能夠被正確拷貝。測試顯示，這些循環引用仍然能夠保持一樣的關係。（例如：內部實例仍然能夠正確的引用外部的類實例）

package test.com.ajexperience.utils.deepcopyutil;

import junit.framework.TestCase;

import com.ajexperience.utils.DeepCopyUtil;

public class DeepCopyTestSimpleCircle extends TestCase {
    
    public InnerClass outerToInner = new InnerClass(); // an instance of the inner class
    public DeepCopyTestSimpleCircle pointerToSelf; 
    
    public class InnerClass { // an inner class with a link to the outer class
        DeepCopyTestSimpleCircle innerToOuter;
    }

    public DeepCopyTestSimpleCircle() {
        outerToInner.innerToOuter = this; // link the inner class to the outer class
        this.pointerToSelf = this; // self reference
    }
    
    public static void main(String args[]) throws Exception {
        DeepCopyUtil deepCopyUtil = new DeepCopyUtil(); // used to create deep copies of objects.
        DeepCopyTestSimpleCircle simpleCircle = new DeepCopyTestSimpleCircle(); // create an instance.

        DeepCopyTestSimpleCircle copy = deepCopyUtil.deepCopy(simpleCircle); // deep copy the object.
        
        assertFalse(simpleCircle == copy); // test that they are not equal.
        
        // test that the circular references are in tact.
        assertTrue(copy == copy.outerToInner.innerToOuter);
        assertTrue(copy == copy.pointerToSelf);
    }
}