代码一：
public class IteratorTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String string = (String) iterator.next();
System.out.println(string);
if(string.equals("hello")) {
list.remove(string);
}
}
}
}
结果如下：
会抛出ConcurrentModificationException。
Exception in thread "main" java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:907) at java.util.ArrayList$Itr.next(ArrayList.java:857) at test.IteratorTest.main(IteratorTest.java:17)
代码二：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String string = (String) iterator.next();
System.out.println(string);
if(string.equals("world")) {
list.remove(string);
}
}
}
}
结果如下：
程序竟然正常结束了！
hello world
代码三：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String string = (String) iterator.next();
System.out.println(string);
if(string.equals("java")) {
list.remove(string);
}
}
}
}
结果如下：
依然是ConcurrentModificationException.
hello world java Exception in thread "main" java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:907) at java.util.ArrayList$Itr.next(ArrayList.java:857) at test.IteratorTest.main(IteratorTest.java:15)
应该看看源码，答案就在源码中。
ArrayList对iterator()方法的实现是这样的：
public Iterator<E> iterator() {
return new Itr();
}
ArrayList.java里面有一个内部类：
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
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();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
cursor是下一个要被访问元素的index，lastRet是上一个被访问的元素。初始的时候cursor是0，lastRet是-1。
第一次调用iterator的next方法，会返回elementData[0]。然后cursor变成1，lastRet变成0。
第二次调用iterator的next方法，会返回elementData[1]。然后cursor变成2，lastRet变成1。
......以此类推，直到hasNext()返回false。而hasNext()返回false的条件是，cursor等于size。
来解释一下代码二为什么正常结束：
list里面放着："hello", "world", "java"
初始size=3， cursor=0。
第一次循环：hasNext()为真，next()后，得到"hello", cursor变为1；
第二次循环：hasNext()为真，next()后，得到"world", cursor变为2，这时要做删除操作。删除操作后size变为2。
第三次循环：hasNext()为假，因为cursor = size （都为2），循环退出，程序正常结束。
代码一和代码三会抛出ConcurrentModificationException:
先来看看next方法：
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
第一步会执行checkForComodification():
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
当modCount不等于expectedModCount时，就会抛出这个异常。
expectedModCount在Itr这个内部类中，初始让它等于modCount。
modCount在AbstractList.java中，初始值是0。当List有add，remove等操作，modCount就会加1。
ArrayList.java中的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;
}
所以执行list.remove()后，modCount和expectedCount就不一样了，下一次next()的时候就会报错。代码二是因为hasNext()为false，躲过了这个报错。
正确的做法是用iterator.remove():
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class IteratorTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String string = (String) iterator.next();
System.out.println(string);
if(string.equals("java")) {
iterator.remove();
}
}
}
}
结果如下：
hello world java
Iterator和ConcurrentModificationException
原文：https://www.cnblogs.com/lightning1992/p/11755823.html