java8 foreach 删除一条数据_Foreach删除元素（ArrayList）报错分析
普通循环：利用index实现
增强型循环：通过迭代器实现
示例代码：
public class ArrayListTest {
public static void main(String[] args) {
normalFor(getList()); //普通循环
iterator(getList()); //增强循环-迭代器
forEach(getList()); //增强循环-foreach方式
}
//普通循环
private static void normalFor(List list) {
for (int i = 0 ; i < list.size() ; i++){
if ("b".equalsIgnoreCase(list.get(i)) || "c".equalsIgnoreCase(list.get(i))){
list.remove(i);
}
}
System.out.println("normalFor:"+JSONObject.toJSONString(list));
}
//增强循环-迭代器
private static void iterator(List list) {
Iterator iterator = list.iterator();
while (iterator.hasNext()){
String str = (String) iterator.next();
if ("b".equalsIgnoreCase(str) || "c".equalsIgnoreCase(str)){
iterator.remove();
}
}
System.out.println("iterator:"+JSONObject.toJSONString(list));
}
//增强循环-foreach方式
private static void forEach(List list) {
for (String str : list){
if ("b".equalsIgnoreCase(str) || "c".equalsIgnoreCase(str)){
list.remove(str);
}
}
System.out.println("forEach:"+JSONObject.toJSONString(list));
}
private static List getList(){
List list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
return list;
}
}
输出
normalFor:["a","c","d","e"]
iterator:["a","d","e"]
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at com.qxy.collection.ArrayListTest.forEach(ArrayListTest.java:47)
at com.qxy.collection.ArrayListTest.main(ArrayListTest.java:21)
Process finished with exit code 1
从上边可以看出
类型
输出结果
普通循环
正常输出，结果错误
增强循环-迭代器
正常输出，结果正确
增强循环-foreach
报异常
普通循环
普通循环，底层是数组，在remove操作时，被删除元素的后边所有的元素，会往前挪挪一位。咱们还是看图，比较直观
当第一次删除时，此时的 i = 1，b正常删除，c、d、e此时都往前挪了一位，然后执行了 i+1 变成了2，也就是d 的位置，一直往后都没匹配到c，所以导致c为正常删除。
增强循环-迭代器
在分析之前，我们先来看看反编译之后的代代码
public class ArrayListTest {
...
private static void iterator(List list) {
Iterator iterator = list.iterator();
while(true) {
String str;
do {
if (!iterator.hasNext()) {
System.out.println("iterator:" + JSONObject.toJSONString(list));
return;
}
str = (String)iterator.next();
} while(!"b".equalsIgnoreCase(str) && !"c".equalsIgnoreCase(str));
iterator.remove();//不同的地方：调用迭代器的remove方法
}
}
private static void forEach(List list) {
Iterator var1 = list.iterator();
while(true) {
String str;
do {
if (!var1.hasNext()) {
System.out.println("forEach:" + JSONObject.toJSONString(list));
return;
}
str = (String)var1.next();
} while(!"b".equalsIgnoreCase(str) && !"c".equalsIgnoreCase(str));
list.remove(str);//不同的地方：调用list的remove方法
}
}
...
}
从上边的代码来看，迭代器 和 foreach 的方法很类似，唯一的区别就是 remove() 方法
迭代器调用的是 Iterator 类的 remove 方法
foreach调用的是 ArrayList类 的remove方法
那么我们去看下 他们各自 remove方法到底是怎么实现的
迭代器方式，那么需要先看 ArrayList.class
public Iterator iterator() {
return new Itr();
}
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount; //这个属性比较重要
Itr() {}
...
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification(); //第一步
try {
ArrayList.this.remove(lastRet); //第二步：调用list的remove方法
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount; //第三步：modCount是remove方法去维护更新，由于第一步中校验 modCount 和 expectedModCount 是否相当等
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
...
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
可以看到，list.iterator() 返回的是一个 Itr对象(ArrayList私有的实例内部类)，执行 iterator.remove() 方法时，
第一步：先调用 checkForComodification() 方法，此方法作用：modCount 和 expectedModCount 是否相当
第二步：也就是foreach方式中调用的remove方法，在ArrayList内部的remove方法，会更新modCount属性
第三步：将更新后的modCount重新赋值给expectedModCount变量，看这里！！！看这里！！！相比于有一个更新操作，才通过了上边第一步的校验！！！
到此，你可能还想看看，ArrayList类中的remove方法
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
看到此方法中，有一个modCount++的操作，也就是说，modCount会一直更新变化。
总结：jdk源码离我们那么近，但是，总是这样完美的擦肩而过，以后要多啃啃，不要错过！！！