吃透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<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        for (Integer i : list) {System.out.println(i);
        }
    }

编译后的.class 文件如下

public static void main(String[] args) {List<Integer> 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<T> {
    /**
     * 返回类型为 {@code T} 的元素上的迭代器。*/
    Iterator<T> iterator();

    /**
     * 对{@code Iterable} * 的每个元素执行给定的操作，直到处理完所有元素或该操作引发 * 异常为止。除非实现类另行指定，* 否则 * 操作将以迭代顺序执行（如果指定了迭代顺序 *）*
     * @since 1.8 JDK1.8 新加的
     */
    default void forEach(Consumer<? super T> 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<T> 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<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        list.forEach(integer -> System.out.println(integer));
    }

或者写的更明白一些

public static void main(String[] args) {List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        list.forEach(new Consumer<Integer>() {
            @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<E> {
    /**
     * 如果被迭代遍历的集合还没有被遍历完，返回 True
     */
    boolean hasNext();

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

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

    /**
     * 对剩余的每个元素执行给定的操作，直到所有元素 * 已处理完毕或该操作引发异常。* 如果指定了操作，则按迭代顺序执行操作。操作引发的异常会中继给调用者。* @since 1.8
     */
    default void forEachRemaining(Consumer<? super E> 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 则不然，每次调用都返回一个从头开始的迭代器，各个迭代器之间互不影响。