Java 集合遍历删除：4种常见错误与3种正确写法（附ConcurrentModificationException分析）

在Java开发中，List作为最常用的集合类型之一，其元素删除操作看似简单却暗藏玄机。许多开发者都曾掉入过遍历删除的陷阱，轻则导致数据遗漏，重则引发 ConcurrentModificationException 异常。本文将深入剖析四种典型错误场景，并提供三种经得起考验的正确写法，最后从源码层面解读异常触发机制。

1. 四种典型的错误删除方式

1.1 普通for循环的正向遍历删除

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 3, 4));
for (int i = 0; i < numbers.size(); i++) {
    if (numbers.get(i) == 3) {
        numbers.remove(i);
    }
}
System.out.println(numbers); // 输出：[1, 2, 3, 4]

问题分析 ：当删除元素后，后续元素会前移导致索引错位。如上例中删除第一个3后，第二个3的索引从3变为2，但循环下一次的i已经是3，导致漏删。

1.2 增强for循环删除

List<String> fruits = new ArrayList<>(Arrays.asList("apple", "banana", "orange"));
for (String fruit : fruits) {
    if (fruit.startsWith("a")) {
        fruits.remove(fruit); // 抛出ConcurrentModificationException
    }
}

问题分析 ：增强for循环底层使用迭代器实现，任何直接对集合的结构修改都会导致迭代器的 modCount 与 expectedModCount 不一致，从而抛出异常。

1.3 迭代器遍历中使用集合remove方法

List<Double> prices = new ArrayList<>(Arrays.asList(1.99, 2.99, 3.99));
Iterator<Double> it = prices.iterator();
while (it.hasNext()) {
    if (it.next() < 3) {
        prices.remove(it.next()); // 抛出ConcurrentModificationException
    }
}

问题分析 ：虽然使用了迭代器，但实际删除操作仍通过集合本身执行，同样会导致 modCount 变化，违反快速失败(fail-fast)机制。

1.4 Lambda表达式中的陷阱

List<Character> chars = new ArrayList<>(Arrays.asList('a', 'b', 'c'));
chars.removeIf(c -> {
    chars.add('d'); // 并发修改
    return c == 'b';
});

问题分析 ： removeIf 虽然安全，但在Predicate中修改集合仍会导致 ConcurrentModificationException 。

2. 三种正确的删除方式

2.1 迭代器专用remove方法

List<String> colors = new ArrayList<>(Arrays.asList("red", "green", "blue"));
Iterator<String> iterator = colors.iterator();
while (iterator.hasNext()) {
    if (iterator.next().length() > 3) {
        iterator.remove(); // 安全删除当前元素
    }
}

优势 ：

• 迭代器自身维护修改状态
• 删除后自动调整游标位置
• 适用于所有Collection实现类

2.2 倒序for循环删除

List<Integer> primes = new ArrayList<>(Arrays.asList(2, 3, 5, 7, 11));
for (int i = primes.size() - 1; i >= 0; i--) {
    if (primes.get(i) > 5) {
        primes.remove(i);
    }
}

适用场景 ：

• 需要根据索引删除时
• 性能要求较高的场景（比迭代器略快）
• 注意：不适合LinkedList等非随机访问集合

2.3 Java 8的removeIf方法

List<LocalDate> dates = new ArrayList<>(Arrays.asList(
    LocalDate.now(), 
    LocalDate.now().plusDays(1)
));
dates.removeIf(date -> date.isAfter(LocalDate.now()));

特性对比 ：

方法	线程安全	代码简洁度	性能	适用场景
迭代器remove	不安全	中等	较好	复杂条件删除
倒序for循环	不安全	中等	最佳	简单条件+随机访问
removeIf	不安全	最佳	较好	Lambda表达式场景

3. ConcurrentModificationException深度解析

3.1 异常触发机制

ArrayList的迭代器实现中维护了两个关键字段：

int expectedModCount = modCount;  // 初始化时记录修改次数

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

当发生以下操作时 modCount 会增加：

• 添加元素(add)
• 删除元素(remove)
• 清空集合(clear)

3.2 源码级执行流程

以ArrayList的迭代器为例：

1. 创建迭代器时记录当前 modCount
2. 每次调用next()前检查 checkForComodification()
3. 迭代器自身的remove()会同步更新 expectedModCount

public void remove() {
    if (lastRet < 0)
        throw new IllegalStateException();
    checkForComodification();

    try {
        ArrayList.this.remove(lastRet);
        cursor = lastRet;
        lastRet = -1;
        expectedModCount = modCount; // 关键同步操作
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

3.3 线程安全解决方案

对于多线程环境，推荐使用以下方案：

// 方案1：使用CopyOnWriteArrayList
List<String> safeList = new CopyOnWriteArrayList<>(data);
for (String item : safeList) {
    if (condition) {
        safeList.remove(item);
    }
}

// 方案2：加锁保护
List<Integer> syncList = Collections.synchronizedList(new ArrayList<>());
synchronized (syncList) {
    Iterator<Integer> it = syncList.iterator();
    while (it.hasNext()) {
        if (it.next() % 2 == 0) {
            it.remove();
        }
    }
}

4. 性能对比与最佳实践

4.1 不同实现类的删除效率

测试数据（100万元素，删除50%）：

集合类型	迭代器remove	倒序for循环	removeIf
ArrayList	15ms	12ms	18ms
LinkedList	32ms	2100ms	35ms

结论 ：

• ArrayList适合索引访问的删除
• LinkedList必须使用迭代器
• Java8+环境优先考虑removeIf

4.2 特殊场景处理建议

批量删除优化 ：

// 传统方式
list.removeIf(item -> item.contains("test"));

// 更高效的批量删除（当条件复杂时）
Set<String> toRemove = list.stream()
    .filter(item -> expensiveCheck(item))
    .collect(Collectors.toSet());
list.removeAll(toRemove);

对象相等性陷阱 ：

List<Integer> nums = Arrays.asList(100, 200, 300);
nums.remove(100);    // 按索引删除
nums.remove(Integer.valueOf(100)); // 按对象删除

并行流注意事项 ：

List<String> data = Collections.synchronizedList(new ArrayList<>());
data.parallelStream()
    .filter(s -> !s.isEmpty())
    .forEach(s -> data.remove(s)); // 仍然可能抛出异常

在实际项目中，推荐结合代码审查工具配置以下规则：

• 禁止在迭代中使用集合的remove/add方法
• 对大型集合优先使用removeIf
• 多线程环境必须使用线程安全方案