Java遍历集合时删除元素抛出异常ConcurrentModificationException的排查与解决

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

// 方式1：普通 for 循环（依赖下标）
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

// 方式2：增强 for 循环（语法糖，底层也是迭代器）
for (String s : list) {
    System.out.println(s);
}

// 方式3：显式迭代器（最灵活）
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

Iterator<String> it = list.iterator();
while (it.hasNext()) {   // 1. 问：还有吗？
    String s = it.next(); // 2. 拿：拿到下一个，并且游标后移
    System.out.println(s);
}

List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

// ✅ 正确：使用迭代器删除偶数
Iterator<Integer> it = numbers.iterator();
while (it.hasNext()) {
    Integer num = it.next();
    if (num % 2 == 0) {
        it.remove();  // 安全删除当前元素
    }
}
System.out.println(numbers);  // [1, 3, 5]

Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
    // it.remove();  // ❌ 报错！IllegalStateException（没有先 next）
    Integer num = it.next();
    it.remove();
    // it.remove();  // ❌ 报错！IllegalStateException（连续删除两次）
}

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

// ❌ 错误！抛出 ConcurrentModificationException
for (String s : list) {
    if ("B".equals(s)) {
        list.remove(s);  // 直接操作集合，导致迭代器检测到 modCount 变化
    }
}

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "D"));

ListIterator<String> lit = list.listIterator();
// 1. 从前往后遍历
while (lit.hasNext()) {
    String s = lit.next();
    if ("B".equals(s)) {
        lit.add("C");   // 在 B 后面插入 C（游标自动跳过新元素）
    }
}
System.out.println(list);  // [A, B, C, D]

// 2. 从后往前遍历
while (lit.hasPrevious()) {
    String s = lit.previous();
    if ("C".equals(s)) {
        lit.set("X");   // 修改当前元素为 X
    }
}
System.out.println(list);  // [A, B, X, D]

// AbstractList 源码片段
public abstract class AbstractList<E> {
    protected transient int modCount = 0;  // 集合结构修改次数
    
    // 迭代器内部
    private class Itr implements Iterator<E> {
        int expectedModCount = modCount;  // 创建迭代器时保存的快照
        
        public E next() {
            checkForComodification();  // 每次 next 都检查
            // ...
        }
        
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }
}

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("A");
list.add("B");

for (String s : list) {  // 底层是 CopyOnWrite 迭代器（安全失败）
    if ("A".equals(s)) {
        list.add("C");   // ✅ 不会抛异常！因为遍历的是快照
    }
}
System.out.println(list);  // [A, B, C]（新增元素不影响正在进行的遍历）

public class MyCollection<T> implements Iterable<T> {
    private Object[] elements = new Object[10];
    private int size = 0;

    public void add(T item) {
        elements[size++] = item;
    }

    // 1. 实现 Iterable 接口，返回迭代器
    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    // 2. 自定义迭代器内部类
    private class MyIterator implements Iterator<T> {
        private int cursor = 0;

        @Override
        public boolean hasNext() {
            return cursor < size;
        }

        @SuppressWarnings("unchecked")
        @Override
        public T next() {
            if (!hasNext()) throw new NoSuchElementException();
            return (T) elements[cursor++];
        }

        // 简化版本，不支持 remove
    }

    public static void main(String[] args) {
        MyCollection<String> mc = new MyCollection<>();
        mc.add("Java");
        mc.add("Iterator");
        for (String s : mc) {  // 增强 for 循环生效！
            System.out.println(s);
        }
    }
}

List<String> list = Arrays.asList("A", "B", "C", "D");
Iterator<String> it = list.iterator();

it.next();  // 跳过 A
it.forEachRemaining(System.out::println);  // 输出 B C D（从当前位置到末尾）

// 问题 1：下面代码会抛出什么异常？为什么？
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
for (String s : list) {
    if ("B".equals(s)) {
        list.remove(s);
    }
}

// 问题 2：下面代码中，ArrayList 和 CopyOnWriteArrayList 的表现有什么不同？
// 场景 A：ArrayList
List<Integer> list1 = new ArrayList<>(Arrays.asList(1,2,3));
for(Integer i : list1) { if(i==2) list1.remove(i); }

// 场景 B：CopyOnWriteArrayList
List<Integer> list2 = new CopyOnWriteArrayList<>(Arrays.asList(1,2,3));
for(Integer i : list2) { if(i==2) list2.remove(i); }

// 问题 3：ListIterator 和 Iterator 都能删除元素，为什么 ListIterator 还能添加元素？