Java 集合框架系列二：JDK 1.8 Iterable 和 Iterator、Enumerator 和 ListIterator 详解

最新推荐文章于 2022-12-17 11:26:52 发布

青藤光年

最新推荐文章于 2022-12-17 11:26:52 发布

阅读量360

点赞数

文章标签： java 集合迭代

本文链接：https://blog.csdn.net/WYA1993/article/details/108466525

版权

Java 集合框架专栏收录该内容

15 篇文章 2 订阅

订阅专栏

当我们想要遍历集合时，Java 为我们提供了多种选择，通常有以下三种写法：

写法 1：for 循环

    for (int i = 0, len = strings.size(); i < len; i++) {
        System.out.println(strings.get(i));
    }

写法 2：foreach 循环

    for (String var : strings) {
        System.out.println(var);
    }

写法 3：Iterator

    Iterator iterator = strings.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }

那么以上三种遍历方式有何区别呢？for 循环就是根据下标来获取元素，这个特性与数组十分吻合。foreach 则主要对类似链表的结构提供遍历支持，链表没有下标。Iterator 就是我们今天要讲述的主角，事实上 foreach 循环就是 Java 的语法糖，虚拟机在使用前端编译器将 .java 文件编译为 .class 字节码文件时会把 foreach 转换为 Iterator 迭代器遍历的方式。如下例子：

源码

	public void testForEach(){
        List<String> list = new ArrayList<>();
        for (String s : list) {
            
        }
    }

字节码

 0 new #2 <java/util/ArrayList>
 3 dup
 4 invokespecial #3 <java/util/ArrayList.<init>>
 7 astore_1
 8 aload_1
 9 invokeinterface #4 <java/util/List.iterator> count 1
14 astore_2
15 aload_2
16 invokeinterface #5 <java/util/Iterator.hasNext> count 1
21 ifeq 37 (+16)
24 aload_2
25 invokeinterface #6 <java/util/Iterator.next> count 1
30 checkcast #7 <java/lang/String>
33 astore_3
34 goto 15 (-19)
37 return

Iterable

那么，为什么集合可以进行 foreach 遍历，而我们自己定义的 Java 对象却不可以呢？

Iterable 是可迭代的意思，作用是为集合类提供 foreach 循环的支持，所以 Iterable 也是在 JDK 1.5 才开始提供的。由于使用 for 循环需要通过位置获取元素，而这种获取方式仅有数组支持。Iterable 就可以让不同的集合类自己提供遍历的最佳方式。在 Iterable 的类文档里只有一句话：实现此接口允许对象成为 “for-each 循环”语句的目标。

Iterable 的主要方法是返回一个Iterator对象，如果想让一个 Java 对象支持 foreach，只要实现 Iterable 接口，就可以像集合那样，通过 Iterator iterator = strings.iterator() 方式或者使用 foreach 进行遍历了。

public interface Iterable<T> {
    /**
     * 返回类型为 T 的元素上的迭代器。
     */
    Iterator<T> iterator();

    /**
     * 对迭代器的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常为止。除非实现类另行指定，
     * 否则此操作将以迭代顺序执行（如果指定了迭代顺序），迭代过程中的异常将抛给调用者。
     *
     * @throws 如果指定的 action 是 null 则抛出 NullPointerException
     * @since 1.8
     */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    /**
     * 在此 Iterable 描述的元素上创建 Spliterator。
     *
     * 默认实现从 Iterable 的 Iterator 创建一个 early-binding Spliterator
     * Spliter 继承了 Iterable 的迭代器的 fail-fast 属性。
     * 通常应重写默认实现。默认实现返回的 Spliterator 具有较差的拆分能力。实现类几乎总能提供更好的实现。
     * 
     * @since 1.8
     */
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Spliterator 是JDK 1.8 引入的一种并行遍历的机制，我们熟悉的Iterator 也提供了对集合数据进行遍历的能力，但后者是顺序遍历，前者是并行遍历，这里不详细介绍。

Iterator

Iterator 是迭代器的意思，是 foreach 遍历的主体。foreach 主要是解决 for 循环依赖下标的问题，为高效遍历更多的数据结构提供了支持。通过 Iterator 的类文档可以了解到如下信息：

Iterator 是集合的迭代器，一般每个集合实现类需要实现 Iterator 提供自己的迭代器，为提供高效遍历提供支持，因为不同的集合可能使用了不同的数据结构，如 ArrarList 使用了数组，LinkedList 使用了链表。
Iterator 是用来替代 JDK 1.0 提供的 Enumeration 类。在 Iterator 出现之前，Hashtable、Vector 等都是通过 Enumeration 进行迭代的，相比于 Enumeration，Iterator 做了如下改进：1.允许迭代过程中删除元素。2.方法名进行了改进。
另外 Enumeration 是不支持 fail-fast 策略的，且 Enumeration 不支持同步，而是 Hashtable、Vector 等类实现 Enumeration 时添加了同步。

public interface Iterator<E> {
    /**
     * 如果迭代有更多元素，则返回 true
     */
    boolean hasNext();

    /**
     * 返回迭代中的下一个元素
     * @throws 如果没有下个元素则抛出 NoSuchElementException 
     */
    E next();

    /**
     * 从基础集合中删除最后一个元素，此方法在调用 next() 方法后最多执行一次
     *
     * @throws 如果不支持此操作则抛出 UnsupportedOperationException
     * @throws 如果没有调用 next() 方法或者调用 next() 方法后已经调用了 remove() 方法则抛出 IllegalStateException
     */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * 对剩余的每个元素执行给定的操作，直到所有元素都已处理或操作引发异常。
     * 如果指定了迭代顺序，则按迭代顺序执行操作。操作引发的异常被中继到调用方。
     *
     * @throws 如果指定的 action 是 null 则抛出 NullPointerException
     * @since 1.8
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

Iterable 和 Iterator 有什么关系

实现了 Iterator 接口的类就具有迭代元素的能力，实现了 Iterable 的类就具备 for-each 的能力。
Iterable 可以返回 Iterator 实例，所以实现了 Iterable 的类就可以使用 Iterator。
集合 Collection、List、Set 都是 Iterable 的实现类，所以他们及其他们的子类都可以使用 for-each 进行迭代，而且如 ArrayList 等都在内部创建了私有的 Iterator 的实现类作为迭代器。

为什么不把 Iterable 和 Iterator 合并到 Iterable 中？

因为一个类可以实现多种 Iterator，提供多种迭代器，如果把 Iterator 的功能合并到 Iterable 中，无疑会增加实现的难度。
单一职责原则。

ListIterator

ListIterator 也是在 JDK 1.2 提供的迭代器，它继承了 Iterator 接口，它只能用于 List 的访问。ListIterator 允许沿双向遍历列表，在迭代期间修改列表，并获得迭代器在列表中的当前位置。ListIterator 没有当前元素；它的游标位置始终位于调用 previous() 返回的元素和调用 next() 返回的元素之间。长度为 n 的列表的迭代器有 n+1 个可能的游标位置。

public interface ListIterator<E> extends Iterator<E> {
    // Query Operations

    /**
     * 如果存在下一个元素返回 true
     */
    boolean hasNext();

    /**
     * 返回下一个元素，如果没有则抛出 NoSuchElementException 
     */
    E next();

    /**
     * 如果存在前一个元素返回 true
     */
    boolean hasPrevious();

    /**
     * 返回前一个元素，如果没有则抛出 NoSuchElementException 
     */
    E previous();

    /**
     * 返回后续调用 next 将返回的元素的索引。（如果迭代器位于列表末尾，则返回列表大小，在开头则是 0。）
     */
    int nextIndex();

    /**
     * 返回后续调用 previous 将返回的元素的索引。（如果迭代器位于列表的开头，则返回-1。）
     */
    int previousIndex();


    // Modification Operations

    /**
     * 从列表中删除 next 或 previous 返回的最后一个元素。
     * 只有在调用 next 或 previous 之后还没有调用 add 才能执行此操作且只能调用一次否则抛出 IllegalStateException 。
     * 如果不支持此操作抛出 UnsupportedOperationException 
     */
    void remove();

    /**
     * 用指定的元素替换 next 或 previous 返回的最后一个元素
     * 只有在上一次调用 next 或 previous 之后没有调用 remove 或 add 能进行此调用
     * 
     * @throws 迭代器不支持此操作抛出 UnsupportedOperationException 
     * @throws 指定的元素类型不匹配抛出 ClassCastException 
     * @throws 指定的元素无法添加到列表中抛出 IllegalArgumentException 
     * @throws 调此方法之前没有调 next 或 previous 方法抛出 IllegalStateException 
     * 		   调 next 或 previous 方法后调了 remove 或 add 方法又调用当前方法抛出 IllegalStateException 	
     */
    void set(E e);

    /**
     * 在列表中插入指定的元素，元素会插入到 next 将返回的元素之前（如果有）以及 previous 将返回的元素之后（如果有）
     *
     * @throws 迭代器不支持此操作抛出 UnsupportedOperationException 
     * @throws 指定的元素类型不匹配抛出 ClassCastException 
     * @throws 指定的元素无法添加到列表中抛出 IllegalArgumentException 
     */
    void add(E e);
}

ListIterator 使用

/**
 * JDK 1.8 {@link ListIterator} 测试
 *
 * @author Cruise
 * @version 1.0
 * @since 2020/9/8
 */
public class ListIteratorTest {
    private ArrayList<String> list = new ArrayList<>();
    @Before
    public void init(){
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
    }

    /**
     * 测试向后遍历
     *
     * 0,-1
     * a
     * 1,0
     * b
     * 2,1
     * c
     * 3,2
     * d
     * 4,3
     * e
     * 5,4
     * f
     * 6,5
     */
    @Test
    public void testNext(){
        ListIterator<String> iterator = list.listIterator();
        System.out.println(iterator.nextIndex() + "," + iterator.previousIndex());
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
            System.out.println(iterator.nextIndex() + "," + iterator.previousIndex());
        }
    }

    /**
     * 测试向前遍历
     *
     * 6,5
     * f
     * 5,4
     * e
     * 4,3
     * d
     * 3,2
     * c
     * 2,1
     * b
     * 1,0
     * a
     * 0,-1
     *
     */
    @Test
    public void testPrevious(){
        // 定位到列表末尾
        ListIterator<String> iterator = list.listIterator(list.size());
        System.out.println(iterator.nextIndex() + "," + iterator.previousIndex());
        while (iterator.hasPrevious()) {
            System.out.println(iterator.previous());
            System.out.println(iterator.nextIndex() + "," + iterator.previousIndex());
        }
    }

    @Test
    public void testSet(){
        ListIterator<String> iterator = list.listIterator(list.size());
        while (iterator.hasPrevious()) {
            // iterator.set("1"); 抛出 IllegalStateException
            String previous = iterator.previous();
            if ("e".equals(previous)) {
                //iterator.remove();// 先 remove 抛出 IllegalStateException
                // iterator.set("1");
                // iterator.add("1");// 先 add 抛出 IllegalStateException
                iterator.set("2");
            }
        }
    }
}

Enumerator

Enumerator 实现了 Enumeration 接口，Enumeration 接口不支持对元素的删除操作。

public interface Enumeration<E> {
    boolean hasMoreElements();
    E nextElement();
}

青藤光年

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录