吃透Java系列之Iterable和Iterator

前言：

作为吃透Java集合的开篇，我们从集合的最顶层接口（Iterable）撸起，通过本篇我们要明白三个问题：
1、什么是Iterable
2、什么是Iterator
3、Iterable和Iterator有什么关系

一：什么是Iterable

JDK描述：实现此接口允许对象成为“ for-each循环”语句的目标。

那么什么是“ for-each循环”：“ for-each循环”是Java提供的语法糖，实际上还是通过迭代器Iterator迭代遍历，如下例子：

public static void main(String[] args) {
        List list = new ArrayList<>(Arrays.asList(1, 2, 3));
        for (Integer i : list) {
            System.out.println(i);
        }
    }

编译后的.class文件如下

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

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

    }

通过上面例子我们明白了“ for-each循环”的本质。言归正传，接下来看Iterable源码：

/**
 * 实现此接口允许对象成为“ for-each循环”语句的目标
 */
public interface Iterable {
    /**
     * 返回类型为{@code T}的元素上的迭代器。
     */
    Iterator iterator();

    /**
     * 对{@code Iterable} *的每个元素执行给定的操作，直到处理完所有元素或该操作引发*异常为止。除非实现类另行指定，
     * 否则*操作将以迭代顺序执行（如果指定了迭代顺序*）
     *
     * @since 1.8 JDK1.8新加的
     */
    default void forEach(Consumer action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    /**
     * 在此* {@code Iterable}描述的元素上创建一个{@link Spliterator}。
     * 默认实现从iterable的Iterator创建一个early-binding拼接器。 Spliter继承了iterable的迭代器的fail-fast属性。
     *
     * @since 1.8 JDK1.8新加的
     */
    default Spliterator spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Iterable中定义了三个函数，其中后面两个是1.8新加的，具体分析一下这三个函数：

iterator()返回迭代器实例，通过这个实例来实现对元素的遍历，比如ArrayList中Itr内部类实现了iterator接口，关于iterator接口我们后面会详细分析。
forEach 对 Iterable 的每个元素执行给定的操作，具体指定的操作需要自己写Consumer接口通过accept方法回调出来。很简单，我们看一下例子就明白了

public static void main(String[] args) {
        List list = new ArrayList<>(Arrays.asList(1, 2, 3));
        list.forEach(integer -> System.out.println(integer));
    }

或者写的更明白一些

public static void main(String[] args) {
        List list = new ArrayList<>(Arrays.asList(1, 2, 3));
        list.forEach(new Consumer() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
    }

输出结果为：

1
2
3
1
2
3

spliterator() 通过一个顺序遍历的Iterator对象获取一个并行遍历的Spliterator对象；
关于Spliterator：Spliterator（splitable iterator可分割迭代器）接口是Java为了并行遍历数据源中的元素而设计的迭代器，这个可以类比最早Java提供的顺序遍历迭代器Iterator，但一个是顺序遍历，一个是并行遍历。
对于Spliterator接口的设计思想，应该要提到的是Java7的Fork/Join(分支/合并)框架，总得来说就是用递归的方式把并行的任务拆分成更小的子任务，然后把每个子任务的结果合并起来生成整体结果。
关于Spliterator我们先了解这么多，毕竟不是这里要介绍的重点。

二：什么是Iterator

Iterator是顺序遍历迭代器，jdk中默认对集合框架中数据结构做了实现。
Iterator在实际应用中有一个比较好的点就是，可以一边遍历一遍删除元素。

public interface Iterator {
    /**
     * 如果被迭代遍历的集合还没有被遍历完，返回True
     */
    boolean hasNext();

    /**
     * 返回集合里面的下一个元素
     */
    E next();

    /**
     * 删除集合里面上一次next()方法返回的元素
     *
     */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * 对剩余的每个元素执行给定的操作，直到所有元素*已处理完毕或该操作引发异常。
     * 如果指定了操作，则按迭代顺序执行操作。操作引发的异常会中继给调用者。
     * @since 1.8
     */
    default void forEachRemaining(Consumer action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

前三个函数没什么好说的，注释已经说得很清楚了，那么我们来看一下最后一个函数
forEachRemaining与我们刚才了解的Iterable中的forEach有什么区别呢？

forEachRemaining()方法内部是通过使用迭代器Iterator遍历所有元素，forEach()方法内部使用的是增强for循环。
forEach()方法可以多次调用，forEachRemaining()方法第二次调用不会做任何操作，因为不会有下一个元素。

三：Iterable和Iterator有什么关系

Iterator是迭代器接口，实现此接口的实例可以对元素集合进行迭代遍历，而Iterable是为了只要实现该接口就可以使用foreach进行迭代
Iterable中封装了Iterator接口，只要实现了Iterable接口的类，就可以使用Iterator迭代器了。
集合Collection、List、Set都是Iterable的实现类，所以他们及其他们的子类都可以使用foreach进行迭代。
Iterator中和核心的方法next(),hasnext(),remove(),都是依赖当前位置，如果这些集合直接实现Iterator，则必须包括当前迭代位置的指针。当集合在方法间进行传递的时候，由于当前位置不可知，所以next()之后的值，也不可知。而当实现Iterable则不然，每次调用都返回一个从头开始的迭代器，各个迭代器之间互不影响。