先来看下面的示例：
public class Demo {
public static void main(String[] args) throws IOException {
List<String> list = new LinkedList<>();
list.add("唐僧");
list.add("孙悟空");
list.add("猪八戒");
list.add("沙僧");
list.add("小白龙");
ListIterator<String> iterator = list.listIterator();
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
// System.out.println(iterator.next());// 会抛出NoSuchElementException异常
}
}
/**
* 打印结果：
* 唐僧
* 孙悟空
* 猪八戒
* 沙僧
* 小白龙
*/那么该迭代器的原理到底是怎样的？查看该类的源码：
/**
* ListIterator<E>迭代器的实现类
*/
private class ListItr implements ListIterator<E> {
// 全局变量，上一次执行 next() 或者 previos() 方法时的节点
private Node<E> lastReturned;
// 后继结点
private Node<E> next;
// 后继结点的索引
private int nextIndex;
// 将修改次数modCount赋给expectedModCount
// modCount是指实际修改次数
// expectedModCount是指期望修改次数
private int expectedModCount = modCount;
/**
* 带参构造器
* @param index 指定索引
*/
ListItr(int index) {
// assert isPositionIndex(index);
// 对next和nextIndex进行赋值，所以next就是根据索引index查询出来的结点
next = (index == size) ? null : node(index);
nextIndex = index;
}
/**
* 判断是否还有下一个结点
* @return 如果还有后继结点则返回true，否则返回false
*/
public boolean hasNext() {
// nextIndex表示当前结点的索引
// size表示元素的实际个数
// 如果nextIndex小于size则表示仍然还有后继结点，如果大于等于size那么表示要么是尾结点，要么索引越界了
return nextIndex < size;
}
// 取下一个元素
public E next() {
// 1. 检查modCount和expectedModCount是否相等，如果不相等，表示发生了修改
checkForComodification();
// 2. 判断是否有下一个元素，如果没有则抛出NoSuchElementException异常
if (!hasNext()) // 表示hashNext()为false才会执行
throw new NoSuchElementException();
// 3. 保存next结点
lastReturned = next;
// 4. 迭代器指向下一个结点
next = next.next;
// 5. 索引加1
nextIndex++;
// 6. 返回旧next结点的内容
return lastReturned.item;
}
/**
* 判断是否有前驱结点
* @return 如果有前驱结点返回true，否则返回false
*/
public boolean hasPrevious() {
// 即判断nextIndex是否大于0
return nextIndex > 0;
}
/**
* 获取前驱结点
* @return 返回前驱结点
*/
public E previous() {
// 1. 检查modCount和expectedModCount是否相等，如果不相等，表示发生了修改
checkForComodification();
// 2. 判断是否有上一个元素，空表或只有一个元素都没有前驱结点，如果没有则抛出NoSuchElementException异常
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
/**
* 返回下一个结点的索引
* @return 下一个结点的索引值，从0开始的
*/
public int nextIndex() {
// 直接返回nextIndex即可
return nextIndex;
}
/**
* 返回前驱结点的索引
* @return 前驱结点的索引
*/
public int previousIndex() {
// 即nextIndex减去1的结果
return nextIndex - 1;
}
/**
* 使用迭代器进行迭代的时候不能进行调用list.remove()或list.add()删除修改元素，否则会抛出ConcurrentModificationException异常
* 所以如果要增加或删除元素需要使用迭代器Iterator内部的remove()和add()方法
*/
public void remove() {
// 1. 检查modCount和expectedModCount是否相等，如果不相等，表示发生了修改
checkForComodification();
// 2. 判断lastReturned是否为null来判断迭代器的状态
if (lastReturned == null)
throw new IllegalStateException();
// 3. 获取上一个结点的next结点的next结点，就是当前结点的后继结点
Node<E> lastNext = lastReturned.next;
// 4. 删除当前结点
unlink(lastReturned);
if (next == lastReturned)
// 重新设置next结点，该指向被删除结点的下一个结点
next = lastNext;
else
nextIndex--;
// 将lastReturned置为null，便于回收
lastReturned = null;
// 同时expectedModCount修改次数加1
expectedModCount++;
}
/**
* 修改结点的值
* @param e 新值
*/
public void set(E e) {
// 1. 检查迭代器的状态
if (lastReturned == null)
throw new IllegalStateException();
// 2. 检查在迭代器进行迭代时是否修改了List集合
checkForComodification();
// 3. 直接修改当前结点的item属性值
lastReturned.item = e;
}
/**
* 添加结点
* @param e 待添加的结点内
*/
public void add(E e) {
// 1. 检查在迭代时是否有修改List集合
checkForComodification();
// 2. 将lastReturned置为null
lastReturned = null;
// 3. 判断next是否为null
// 3.1 如果为null，表示next是尾结点，那么将结点添加在末尾即可
if (next == null)
linkLast(e);
// 3.2 表示不为null，那么插入在next结点之前
else
linkBefore(e, next);
// 4. 收尾处理
// 4.1 nextIndex需要加1
nextIndex++;
// 4.2 由于添加了元素，expectedModCount也需要加1
expectedModCount++;
}
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
/**
* 验证modCount的值和expectedModCount的值是否相等，所以当你在调用了ArrayList.add()或者ArrayList.remove()时，只更新了modCount的状态，而迭代器中的expectedModCount未同步，因此才会导致再次调用Iterator.next()方法时抛出异常。
*/
final void checkForComodification() {
// 本质上判断modCount是否等于expectedModCount
if (modCount != expectedModCount)
// 如果不相等表示在迭代时调用了list.add()或list.remove()，那么抛出此异常
throw new ConcurrentModificationException();
}
}其实我们最应该关注的是next()方法，查看下图
从上图可以知道在创建迭代器时，next和nextIndex已经有内容了，看获得ListIterator迭代器的listIterator()方法
其中调用了ListItr构造器，默认索引index为0
所以在调用next()方法时做了三件事：
- 保存next结点，返回该结点的item内容
- 将next结点指向下一个结点
- nextIndex索引加1
注意上面Demo.java中的代码，当第六次调用next()时将抛出NoSuchElementException异常，从next()源码中我们可以查看它首先要判断是否还有下一个元素。
没有下一个元素则抛出该异常。
所以我们如果要遍历迭代器，应该如下：
while (iterator.hasNext()) {
System.out.println(iterator.next());
}但在遍历时可能遇到一个问题，如果你想删除或增加元素怎么办，看下面的代码：
public class Demo {
public static void main(String[] args) throws IOException {
List<String> list = new LinkedList<>();
list.add("唐僧");
list.add("孙悟空");
list.add("猪八戒");
list.add("沙僧");
list.add("小白龙");
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
String next = iterator.next();
if(next.equals("孙悟空")){
list.remove("孙悟空");
}
}
}
}那么运行就会报错
看抛出这个异常的源代码：
原来如果modCount与expectedModCount不相等就会抛出异常。
因为在你迭代之前，迭代器已经被通过list.itertor()创建出来了，如果在迭代的过程中，又对list进行了改变其容器大小的操作，那么Java就会给出异常。因为此时Iterator对象已经无法主动同步list做出的改变，Java会认为你做出这样的操作是线程不安全的，就会给出善意的提醒（抛出ConcurrentModificationException异常）。
那么modCount与expectedModCount是怎么回事呢？
- modCount是在AbstractList中定义的一个变量，表示当前集合的增删次数，初始值为0，而LinkedList间接继承自AbstractList类，所以也有该属性，在该变量在对List进行添加（list.add()）或删除(list.remove())操作时进行加1处理，表示对集合进行了修改。
- expectedModCount是在ListItr类中定义的一个变量，表示当前迭代器的增删次数，该类实现了ListIteratror<E>接口，初始值为modCount，在调用该迭代器内部的添加和删除方法时才变化，平时不变化。
在上面代码中我们在迭代器中调用了LinkedList类的add()或remove()方法，只更新了modCount值，而迭代器中的expectedModCount没有更新，所以会抛出异常。
但如果调用ListIterator内部的remove()或add()方法就不会抛出此异常，因为同时更新了expectedModCount和modCount的值，如下源码能够证明：
使用的目的为了实现快速失败机制（fail-fast），在Java集合中有很多集合都实现了快速失败机制。
快速失败机制产生的条件:当多个线程对Collection进行操作时，若其中某一个线程通过Iterator遍历集合时，该集合的内容被其他线程所改变，则会抛出ConcurrentModificationException异常。
看下面的例子就是多线程产生快速失败：
public class Demo {
public static List<String> list = new LinkedList<>();
public static void main(String[] args) throws IOException {
list.add("唐僧");
list.add("孙悟空");
list.add("猪八戒");
list.add("沙僧");
list.add("小白龙");
new Thread(new Runnable() {
@Override
public void run() {
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
String next = iterator.next();
System.out.println(next);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
list.remove("猪八戒");
}
}).start();
}
}所以无论是单线程还是多线程为了避免抛出ConcurrentModificationException异常，也为了能够在使用迭代器遍历集合时对集合中元素进行增删操作，可以使用迭代器内部的remove()或add()方法。
public class Demo {
public static List<String> list = new LinkedList<>();
public static void main(String[] args) throws IOException {
list.add("唐僧");
list.add("孙悟空");
list.add("猪八戒");
list.add("沙僧");
list.add("小白龙");
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
String next = iterator.next();
if (next.equals("猪八戒")) {
iterator.remove();
}
}
for (String s : list) {
System.out.println(s);
}
}
}
/**
* 打印结果：
* 唐僧
* 孙悟空
* 沙僧
* 小白龙
*/
