ArrayList迭代器源码分析

集合的遍历

Java集合框架中容器有很多种类，如下图中：

对于有索引的List集合可以通过for循环遍历集合：

List<String> list = new ArrayList<>();
​
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
​
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

同样的对于List集合也可以用其迭代器来遍历：

Iterator<String> iterator = list.iterator();
​
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

以及使用增强for循环，但是增强for循环还是用迭代器实现的：

for (String s : list) {
    System.out.println(s);
}

迭代器接口定义

首先来看下迭代器的接口定义如下：

public interface Iterator<E> {
​
    boolean hasNext();
​
    E next();
​
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
​
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

可以看得到迭代器中只定义了四个方法， hasNext() 判断是否有下个元素， Next() 获取下个元素， remove() 删除元素，以及 forEachRemaining() 方法对每个剩余元素都执行给定操作，直到所有元素都被处理或动作引发异常。

ArrayList迭代器源码分析

下面来看ArrayList中的迭代器实现源码：

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
​
    //判断是否有下个元素就是将cursor与集合size进行比较当cursor不等size时表示有下个元素
    //hasNext()方法
    public boolean hasNext() {
        return cursor != size;
    }
​
    //下个元素
    public E next() {
        checkForComodification();
        //当前的游标赋给i
        int i = cursor;
        //判断i是否越界
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        //判断i是否超出elementDate
        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();
        }
    }
}

在迭代过程中对集合做出修改就会抛出异常ConcurrentModificationException，这个异常来源是 checkForComodification() 方法，这个方法的代码如下：

final void checkForComodification() {
    if (modCount != expectedModCount)
    throw new ConcurrentModificationException();
}

modCount是当前集合的版本号，每次对集合进行修改操作都会导致modCount加1，expectedModCount是这个集合的迭代器的版本号，在迭代器的初始话过程中可以看到

int expectedModCount = modCount;

将集合版本号赋给集合的迭代器的版本号，之后的迭代过程中Next()和hasNext()方法都会调用checkForComodification()这个方法来判断两个版本号是否相同。所以在迭代过程中是不可以对集合进行修改的操作。但是迭代器自带的remove()方法却可以对集合进行元素删除操作，这是因为在迭代器的remove()方法中每次删除元素后都有

expectedModCount = modCount;

这个操作来同步集合和集合的迭代器的版本号。因此，使用了迭代器的 remove() 方法对集合中的元素进行了删除操作不会导致ConcurrentModificationException错误。增强for循环是迭代器实现的，因此增强for循环和其同理。在增强for循环中修改元素一样会抛出异常。

增强for循环实现

List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");

for (String s : list) {
    System.out.println(s);
}

上面的代码对list集合用增强for循环进行遍历输出，反编译之后得到如下结果：

List<String> list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
Iterator var2 = list.iterator();

while(var2.hasNext()) {
    String s = (String)var2.next();
    System.out.println(s);
}

所以可以明显的看到增强for循环实现也是通过迭代器，因此也不能在增强for循环中对集合元素进行修改，否则会抛出ConcurrentModificationException异常。

迭代中多次调用Next()

在如下这种情况中在迭代过程中调用了两次Next()方法：

ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
list1.add(5);
Iterator iter = list1.iterator();

while (iter.hasNext()) {

    System.out.println(iter.next());  //两次迭代器next()问题
    System.out.println(iter.next());
}

运行结果是可以打印出所有的元素，但是会抛出NoSuchElementException异常，但是如果减少一个list1中的元素就会正常输出：

public static void main(String[] args) {
    ArrayList<Integer> list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    list1.add(3);
    list1.add(4);
    Iterator iter = list1.iterator();

    while (iter.hasNext()) {

        System.out.println(iter.next());  
        System.out.println(iter.next());
    }

运行可以完整输出，并且不会抛出NoSuchElementException异常。这是因为在每次Next()方法中

if (i >= elementData.length)
    throw new ConcurrentModificationException();

都会做如上的判断，来判断当前的游标是否已经在元素地址外，上面的测试代码中出现异常的代码，一共有五个元素，每次while循环都会迭代两次，所以当第三次进入循环的第一次迭代时可以正常输出的，但是第二次迭代就会出现迭代器中的游标已经等于集合的长度，所以会抛出异常。但是在没有抛出异常的代码中，一共四个元素，每次迭代都会调用两次next()方法，所以一共执行了两次while循环，最后一次循环中的最后一次迭代游标正好在 list.length - 1 处，不会抛出异常，并且下一次循环因为hasNext()方法返回false，所以也不会进入while循环中，所以并不会抛出异常。