How to Avoid java.util.ConcurrentModificationException When Removing Elements from a List

This article shares a common interview question about encountering a java.util.ConcurrentModificationException when trying to remove elements from an ArrayList using a foreach loop.

It first shows the naive code that causes the exception:

public static void main(String[] args) {
    List<String> platformList = new ArrayList<>();
    platformList.add("博客园");
    platformList.add("CSDN");
    platformList.add("掘金");
    for (String platform : platformList) {
        if (platform.equals("博客园")) {
            platformList.remove(platform);
        }
    }
    System.out.println(platformList);
}

Running this code throws java.util.ConcurrentModificationException because the foreach loop internally uses an Iterator, and removing an element directly from the list changes the internal modCount without updating the iterator’s expectedModCount.

The article then explains the iterator’s bytecode, showing that each call to next() invokes checkForComodification(), which compares modCount and expectedModCount. After the explicit remove() call on the list, modCount becomes 4 while expectedModCount remains 3, triggering the exception on the next iteration.

To avoid this problem, three safe approaches are presented:

1. Use Iterator.remove()

By iterating with an Iterator and calling its remove() method, the iterator updates expectedModCount automatically.

public static void main(String[] args) {
    List<String> platformList = new ArrayList<>();
    platformList.add("博客园");
    platformList.add("CSDN");
    platformList.add("掘金");
    Iterator<String> iterator = platformList.iterator();
    while (iterator.hasNext()) {
        String platform = iterator.next();
        if (platform.equals("博客园")) {
            iterator.remove();
        }
    }
    System.out.println(platformList);
}

The output is [CSDN, 掘金].

2. Use a forward-index for loop

Iterate by index and adjust the index after removal to avoid skipping elements.

public static void main(String[] args) {
    List<String> platformList = new ArrayList<>();
    platformList.add("博客园");
    platformList.add("CSDN");
    platformList.add("掘金");
    for (int i = 0; i < platformList.size(); i++) {
        String item = platformList.get(i);
        if (item.equals("博客园")) {
            platformList.remove(i);
            i = i - 1; // correct the index after removal
        }
    }
    System.out.println(platformList);
}

Adjusting i ensures the next element is not missed.

3. Use a reverse for loop

Iterate from the end of the list toward the beginning; removal does not affect the indices of the yet‑to‑be‑processed elements.

public static void main(String[] args) {
    List<String> platformList = new ArrayList<>();
    platformList.add("博客园");
    platformList.add("CSDN");
    platformList.add("掘金");
    for (int i = platformList.size() - 1; i >= 0; i--) {
        String item = platformList.get(i);
        if (item.equals("掘金")) {
            platformList.remove(i);
        }
    }
    System.out.println(platformList);
}

This method avoids index correction because elements after the current index are already processed.

In summary, the article demonstrates why modifying a collection during a foreach iteration leads to ConcurrentModificationException and provides three reliable ways—using Iterator.remove(), a forward-index loop with index adjustment, and a reverse loop—to safely remove elements from a list.