java中集合类forEach删除元素报错：ConcurrentModificationException

    如题所示，我们在java开发中，可能会有这样的一种情况，一个集合使用完了，我们想删除里面所有的元素，可能会遍历他们，然后依次调用删除操作。最简单的我们使用forEach遍历。

    示例如下：

public class ListForEachDel {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("name");
        list.add("id");
        System.out.println(list);
        list.forEach((item) -> {
            // todo
            list.remove(item);
        });
        System.out.println(list);
    }
}

    运行直接报错：

[name, id]
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList.forEach(ArrayList.java:1262)
	at com.xxx.coll.ListForEachDel.main(ListForEachDel.java:22)

    这个问题，我们根据错误堆栈信息，点进源码，发现forEach这里会有一个modCount与expectedModCount相等的判断：

    这里方法一进入，就赋值expectedModCount = modCount，在最后如果没有其它操作应该是相等的，但是这里是删除操作，它会修改modCount：

    我们调用了list.remove(item)

 

    在remove(Object o)方法中调用了fastRemove(index)方法：

   fastRemove里面修改了modCount，所以它与expectedModCount不相等了，抛出异常。

   同理，add方法添加元素也是不行的。也就是说在forEach方法体内部不可以使用增加、删除元素的方法。

    那么，使用for循环可以吗？答案是可以的，但是也分情况：

    1、下标动态约束从小到大删除，不会报错，但是删除不干净。

    2、下标静态约束从小到大删除，会报索引越界错误。

    3、下标从大到小删除，可以全部删除，而且不会报错。

   如下所示，是三个元素的集合，在删除过程中，如果下标判断使用list.size()动态约束，那么不会报错，但是最后会保留元素2。如果使用静态len=list.size()判断，那么会随着元素减少而越界。

    代码如下：

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println("before : " + list);
int len = list.size();
// i < list.size() 下标判断可以动态改变，不会出现越界问题，但是删不干净
// i < len 会出现下标越界
for (int i = 0; i < list.size(); i++) {
	list.remove(list.get(i));
}
System.out.println("after : " + list);

    不报错，但是元素删除有保留：     

    静态下标约束，报错：

 

    删除前面两个不会报错，最后一个元素的时候，下标增长为2，实际只有一个元素，越界。

   

    下标从大到小删除，正常。

    其实，遍历删除元素，一般推荐使用iterator迭代器方式，如下所示，通过迭代器，正常删除数组元素的代码：

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println("before : " + list);
Iterator iterator = list.iterator();
while(iterator.hasNext()) {
	iterator.next();
	iterator.remove();
}
System.out.println("after : " + list);

    运行结果：

 

    这段代码，看着有点奇怪，我们在调用iterator.remove()之前，做了iterator.next()操作，如果不小心，去掉了这句代码会发生什么？

    这是因为在Iter.remove()源码中，每次操作之后，会修改lastRet=-1。

 

    另外，我们在这里可以看到，iterator每次删除之后，会修改expectedModCount=modCount，这样，就不会存在forEach删除那种报错情况。 

     上面说到Iter.remove()会把lastRet修改为-1，这样再次删除就直接报错，那么Iter.next()操作为什么能够修复这个错误，我们看源码便知道原因了：

    在源码这里最后一步，它把lastRet赋值成了下标，只要下标不越界，那么就不会等于-1。

    稍微提一下，就是这里我们调用的是迭代器的remove()方法，如果我们调用的是集合的remove(item)方法会怎么样？

    同样的就报了forEach那种错误，因为第一次删除之后，modCount发生了改变，下一次next的时候，直接就报错。

    有一种特殊情况，就是两个元素的时候，它又不报错了：

 

    这又是什么情况呢？我们要在Iter.hasNext()上找答案：

    这里经历一次删除之后，因为next操作把游标cursor+1了，这时候正好是1，而集合size也从2变为1，所以迭代器判断结束，没有执行可能会报错的代码，只能说这里是一个巧合。 

    最后总结一下集合遍历删除的问题：

    foreach  -> 1 直接报错 ConcurrentModificationException
    iterator  -> 1 无next操作会报错 IllegalStateException 
                       2 有next是正常 
                       3 调用了list.remove(value) 可能不报错，但是还是有问题。
    for         ->  1 下标动态约束从小到大依次删除会删不干净 
                       2 下标静态约束从小到大删除会报越界错误 IndexOutOfBoundsException 
                       3 下标从大到小可以全部删除