Deep and Shallow Copy of Java List Collections: Theory and Practice

Basic Concepts of List Copying

In Java programming, copying List collections is a common requirement. Based on the depth of copying, it can be categorized into shallow copy and deep copy. Shallow copy only duplicates object references, while deep copy creates new object instances. Understanding the difference between these two copy approaches is crucial for writing correct Java programs.

Limitations of Collections.copy() Method

Many developers first consider using the Collections.copy() method for List copying, but this approach has significant limitations. As shown in the Q&A data, when the target list size doesn't match the source list, it throws an IndexOutOfBoundsException. This occurs because Collections.copy() requires the target list to have at least the same capacity as the source list.

Example code demonstrates this issue:

List<SomeBean> wsList = app.allInOne(template);
List<SomeBean> wsListCopy = new ArrayList<SomeBean>(wsList.size());
Collections.copy(wsListCopy, wsList); // Throws IndexOutOfBoundsException

Although the initial capacity is specified through the constructor, the newly created ArrayList is actually empty with zero elements, failing to meet Collections.copy() requirements.

ArrayList Constructor Copying

The best answer recommends using ArrayList constructor for copying, which is the simplest and most efficient approach:

List<SomeBean> newList = new ArrayList<SomeBean>(otherList);

This method creates a new ArrayList instance and adds all elements from the source list to the new list. From an implementation perspective, the ArrayList constructor internally calls the addAll() method, ensuring all elements are properly copied.

This copy approach is a shallow copy, meaning it only duplicates object references without creating new object instances. If elements in the source list are mutable, modifying an element in one list will affect the other list.

Comparison of Other Copy Methods

addAll Method Copying

Besides using the constructor, you can explicitly call the addAll() method:

List<SomeBean> newList = new ArrayList<SomeBean>();
newList.addAll(otherList);

This method is functionally equivalent to constructor copying but has slight performance differences since it requires creating an empty list first before adding elements.

Problems with subList Views

The Q&A data mentions attempting to use the subList() method:

wsListCopy = wsList.subList(0, wsList.size());

This approach creates a view of the original list rather than an independent copy. According to the List interface specification, the list returned by subList() shares the underlying data structure with the original list, and structural modifications to either list may cause ConcurrentAccessException.

Thread Safety Considerations

As mentioned in the best answer, basic List copy operations are not thread-safe. In multi-threaded environments where the source or target lists might be modified by other threads, thread-safe collection classes should be considered.

Using CopyOnWriteArrayList is recommended for concurrent scenarios:

List<SomeBean> newList = new CopyOnWriteArrayList<SomeBean>(otherList);

Or use explicit locking mechanisms for synchronization:

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
// Acquire appropriate locks during read/write operations

Performance Analysis and Optimization

For large lists containing hundreds of objects, copy operation performance is critical. ArrayList constructor copying has O(n) time complexity and O(n) space complexity, making it the optimal choice in most cases.

When frequently copying large lists, consider the following optimization strategies:

• Use ensureCapacity() to pre-allocate space and avoid expansion overhead
• Consider using immutable lists for read-only scenarios
• Choose appropriate thread-safe strategies in concurrent environments

Practical Application Recommendations

When selecting copy methods in actual development, consider the following factors:

1. Data Size: Use any method for small lists; prioritize performance for large lists
2. Concurrency Requirements: Use standard copying in single-threaded environments; require additional synchronization in multi-threaded environments
3. Memory Constraints: Deep copy consumes more memory; shallow copy saves space but requires careful usage
4. Business Requirements: Choose copy depth based on whether independent data copies are needed

By appropriately selecting copy strategies, you can ensure optimal balance between program correctness and performance.