Iterable和Iterator之间的区别以及延伸讨论

本文会讨论几个问题

• Iterable和Iterator的区别
• 讨论为什么需要Iterable和Iterator，只保留Iterator行不行
• 迭代器遍历时，抛出ConcurrentModificationException的原因
• foreach语法糖验证

首先看一下

Iterable的定义

public interface Iterable {
    /**
     * Returns an iterator over elements of type {@code T}.
     *
     * @return an Iterator.
     */
    Iterator iterator();

    default void forEach(Consumer action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    default Spliterator spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

首先，Iterable是一个接口，由具体的类去实现，其中最重要的是这个方法，

Iterator iterator();

下面两个方法是JDK8引入的新特性，其中forEach用于集合的遍历，另外一个不是很懂。

我们看看是有哪些接口和类继承或实现了Iterable

image-20190104101610515.png

我们常见的List，Set，Queue接口都是间接继承了Iterable接口，并且由抽象类AbstractList、AbstractSet、AbstractQueue实现了Iterable接口，也就是这几个抽象类必须去实现iterator()方法。

Tips：在看类的继承结构中，IDEA中可以设置范围，过滤一些杂乱的包。

在看看Iterator接口

public interface Iterator {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

这个接口有几个方法，hasNext()是否有下一个元素，next()获取下一个元素，remove()移除元素。

说到Iterable和Iterator的区别，从接口的定义来说，他们是两个完全不一样的接口；从它们的名字来说，Iterable是表示可迭代的，Iterator是表示一个迭代器。他们的联系在于Iterable接口可以通过iterator()方法拿到Iterator，在JDK8之前，

Iterable也仅仅只有这个方法，也就是说Iterable的作用就是为了拿到Iterator。

接下来思考一个问题，为什么集合类不直接去实现Iterator接口，而是通过实现Iterable，再去拿到Iterator呢？

Iterator迭代器的作用就是为了顺序地遍历元素，为了拿到下一个元素和判断是否有下一个元素，Iterator的实现类必须要有一个游标变量来记录当前的位置。

也就是说，如果集合类直接去实现Iterator接口，那它也必须要有一个游标变量来记录，那这样子直接实现可不可以呢？当然也是可以的，但是会存在一些问题。首先，你的游标变量在第一次迭代之后，什么时候应该去重置呢？这要求Iterator接口提供一个重置reset()的方法。另外一个问题，游标变量只有一个，如果我们对这个集合类同时进行迭代呢？这样子游标变量整个就乱套了。

因此，如果Iterator接口由专门的子类去实现，由子类自己去维护游标变量，每次拿到迭代器，每个迭代器的游标变量是不会相互影响的，这就避免了上面说到的问题。

下面看一下，ArrayList中Itr实现了Iterator接口

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
    // expectedModCount期望，检查迭代器遍历时List是否被修改
    int expectedModCount = modCount;

    Itr() {}

    //判断是否有下一个元素
    public boolean hasNext() {
        return cursor != size;
    }

    //拿到下一个元素
    @SuppressWarnings("unchecked")
    public E next() {
        //检查List是否被修改过
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        // 游标进行加1
        cursor = i + 1;
        // 返回元素
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        //lastRet每次remove()都会被赋值为-1
        if (lastRet < 0)
            throw new IllegalStateException();
        //检查List是否被修改过
        checkForComodification();

        try {
            //移除上次返回的元素
            ArrayList.this.remove(lastRet);
            //因为移除元素的时候，下标会往前移动1位
            //所以相应地cursor也要减1，也就是lastRet返回的位置
            cursor = lastRet;
            //赋值为-1
            lastRet = -1;
            //给expectedModCount重新赋值，要不会引起ConcurrentModificationException
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

在上面的Itr类中，维护了3个变量，一个是游标变量cursor，一个是上次元素返回的下标lastRet，以及防止迭代器遍历中List被修改的变量expectedModCount。

cursor保证了拿到下一个元素以及判断是否有下一个元素，lastRet用于删除元素，expectedModCount则是检查List是否被修改过。

Note：不要在遍历迭代器的时候去修改List，通过List的remove()也好，add()也好，都会引起modCount的改变，从而会导致抛出ConcurrentModificationException异常。

例子

    @Test
    public void testForEach() {
        
        // 初始化List
        List list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        
        //遍历
        for (Integer integer : list) {
            System.out.println(integer);
            if ( integer == 1) {
                list.remove(integer); //对List进行修改，modCount会加1，会导致expectedModCount != modCount会加1,下次调用next()时会抛出ConcurrentModificationException
            }
        }
        
        //这段跟上面的一样，foreach只是语法糖，编译后还是使用迭代器进行遍历的
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println(next);
            if (next == 1) {
                list.remove(next);
            }
        }
        
        // 这个才是正确移除元素的做法
        // 使用迭代器的remove()方法，而不是调用List的remove()方法
        Iterator iterator1 = list.iterator();
        while (iterator1.hasNext()) {
            Integer next = iterator1.next();
            System.out.println(next);
            iterator1.remove();
        }

foreach语法糖验证

原始的.java文件

public class ForEachGrammerTest {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

编译后的.class文件

public class ForEachGrammerTest {
    public ForEachGrammerTest() {
    }

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        Iterator var2 = list.iterator();

        while(var2.hasNext()) {
            Integer integer = (Integer)var2.next();
            System.out.println(integer);
        }

    }
}

从上面两个文件中可以看出来，foreach语法也是要变成迭代器去遍历的呀。

以上内容，个人理解，如有错误，请指正。