How to Avoid ConcurrentModificationException When Removing Elements from a Collection During Iteration?

Avoiding ConcurrentModificationException while Removing Collection Elements during Iteration

Introduction

Modifying a collection while concurrently iterating through it can result in unexpected behavior, including a ConcurrentModificationException. To avoid this issue, different approaches can be employed.

Approach 1: Iterating over a Collection Copy

One method is to create a copy of the collection and iterate over that copy instead of the original collection. This ensures that the original collection is not modified during iteration.

Example:

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

Approach 2: Using the Collection Iterator

Another approach is to use the iterator provided by the original collection. The iterator provides a safe way to traverse the collection and remove elements while iterating.

Example:

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

Alternative Approaches with JDK 8 or Higher

• removeIf: This method takes a predicate and removes all elements that satisfy the predicate from the collection.
• Streams: Using streams, you can filter the collection to create a new collection with the desired elements, then replace the original collection with the filtered collection.

Consideration for Selection

The best approach depends on the specific scenario:

• Collect and Remove: Works with any collection but requires two iterations.
• ListIterator: Efficient for lists and supports add and remove operations.
• Iterator: Only supports remove operations.
• JDK 8 Streams: Iterates once and efficiently filters elements.
• Sublist or Subset: Efficient for removing consecutive elements in a sorted collection.

Additional considerations include:

• Copy approach is safe but incurs the cost of copying the collection.
• Iterator approach may not be supported by all iterator implementations.
• JDK 8 streams modify the reference to the collection, requiring a reassignment.

The above is the detailed content of How to Avoid ConcurrentModificationException When Removing Elements from a Collection During Iteration?. For more information, please follow other related articles on the PHP Chinese website!