How to Safely Remove Elements from a Collection While Iterating in Java?

Removing Elements from Collections While Iterating

When working with collections, it becomes necessary to modify or remove elements while iterating. However, modifying a collection during iteration can lead to a ConcurrentModificationException. To avoid this, several approaches exist:

Iterating over a Copy of the Collection

One approach is to create a copy of the collection before iterating. This allows you to modify the copy without affecting the original collection. Here's an example:

List<Foo> fooListCopy = new ArrayList<>(fooList);
for (Foo foo : fooListCopy) {
    // Modify actual fooList
}

Using the Iterator of the Actual Collection

An alternative approach is to use the iterator of the actual collection. This approach allows you to modify the collection during iteration. Here's an example:

Iterator<Foo> itr = fooList.iterator();
while (itr.hasNext()) {
    // Modify actual fooList using itr.remove()
}

Considerations for Choosing an Approach

Choosing between these approaches depends on several factors:

• Collection Type: The first approach works with any Collection, while the second approach only works with collections that support iterators (e.g., lists, sets).
• Readability: The first approach may be easier to read and understand, especially for beginners.
• Performance: The second approach is more efficient as it does not require creating a copy of the collection.
• Unsupported Remove Operation: The Iterator.remove() method is optional, so not all iterators support removing elements. The first approach avoids this issue by using the Collection.removeAll() method instead.

Additional Techniques for Removing Elements

In addition to these approaches, Java 8 offers several other techniques for removing elements during iteration, including:

• Stream-based Removal: Using stream operations like removeIf() or filter() with collect().
• ListIterator: Using ListIterator.next() to iterate and ListIterator.remove() to remove elements.
• Sublist or Subset: If the collection is sorted, creating a sublist or subset and clearing it can efficiently remove consecutive elements.

The above is the detailed content of How to Safely Remove Elements from a Collection While Iterating in Java?. For more information, please follow other related articles on the PHP Chinese website!