设计模式学习笔记 - 设计模式与范式 -行为型：9.迭代器模式（上）：相比直接遍历集合数据，使用迭代器模式有哪些优势？

概述

上篇文章，我们学习了状态模式。状态模式是状态机的一种实现方式。它通过将事件触发的状态转移和动作执行，拆分到不同的状态类中，以此来避免状态机类中的分支判断逻辑，应对状态机类代码的复杂性。

本章，学习另外一种行为型设计模式，迭代器模式。它用来遍历集合对象。不过，很多编程语言都将迭代器作为一个基础的类库，直接提供出来了。在平时的开发中，特别是业务开发，直接使用即可，很少会自己去实现一个迭代器。不过，知其然知其所以然，弄懂原理能帮助我们更好的使用这些工具类，所以，还是有必要学习一下这个模式。

我们知道，大部分编程语言都提供了多种遍历集合的方式，比如 for 循环、foreach 循环、迭代器等。所以，本章除了讲解迭代器的原理和实现之外，还会重点说一下，相对于其他的遍历方式，利用迭代器来遍历集合的优势。

迭代器模式的实现原理

迭代器模式（Iterator Design Pattern），也叫作游标模式（Cusor Design Pattern）。

它用来遍历集合对象。这里说的 "集合对象" 也叫做 "容器" "聚合对象"，实际上就是包含一组对象的对象，比如数组、链表、树、图、跳表。迭代器将集合对象的遍历操作从集合类中拆分出来，放到迭代器类中，让两者的职责更加单一。

迭代器是用来遍历容器的，所以，一个完整的迭代器模式一般会涉及到容器和容器迭代器 两部分内容。为了达到基于接口而非实现编程的目的，容器包含容器接口、容器实现类，迭代器包含迭代器接口、迭代器实现类。对于迭代器模式，我绘制了一张简单的类图。

接下来通过一个例子，来讲解如何实现一个迭代器。

概述中提到过，大部分编程语言都提供了遍历容器的迭代器类，在平时开发中，直接拿来使用即可，几乎不大可能从零去编写一个迭代器。不过，这里为了讲解迭代器的实现原理，我们假设某个新的编程语言的基础类库中，还没有提供线性容器对应地迭代器，需要从零开始开发。

线性数据结构包括链表和数组，在大部分编程语言中都有对应地类来封装这两种数据结构，在开发中直接拿来使用就可以了。假设在新的编程语言中，这两个数据结分别对应 ArrayList 和 LinkedList 两个类。此外，我们从两个类中抽象出公共的接口，定义为 List 接口，以方便开发者基于接口而非实现编程。

现在，针对 ArrayList 和 LinkedList 两个线性容器，设计实现对应的迭代器。按照之前给出的迭代器类图，先定义一个接口 Iterator 以及针对这两种容器的迭代器实现类 ArrayIterator 和 LinkedIterator。

先看下 Iterator 接口的定义。具体代码如下所示：

java 复制代码

// 接口定义方式一
public interface Iterator<E> {
    boolean hasNext();
    void next();
    E currentItem();
}

// 接口定义方式二
public interface Iterator<E> {
    boolean hasNext();
    E next();
}

Iterator 接口有两种定义方式。

在第一种定义中， next() 函数用来将游标后移一位元素，currentItem() 函数用来返回当前游标执行的元素。
在第二种定义中，返回当前元素与后移一位这两个操作，都要放到同一个函数 next() 中完成。

第一种实现方式更加灵活些，比如可以多次调用 currentItem() 查询当前元素，而不移动游标。所以，在接下来的实现中，我们选择第一种接口定义方式。

现在，我们再来看一下 ArrayIterator 的代码实现，具体如下所示。代码实现非常简单，不需要太多解释。

java 复制代码

public class ArrayIterator<E> implements Iterator<E> {
    private int cursor;
    private ArrayList<E> arrayList;

    public ArrayIterator(ArrayList<E> arrayList) {
        this.cursor = 0;
        this.arrayList = arrayList;
    }

    @Override
    public boolean hasNext() {
        return cursor != arrayList.size(); // 注意这里，cursor在指向最后一个元素的时候，hasNext()仍返回true
    }

    @Override
    public void next() {
        cursor++;
    }

    @Override
    public E currentItem() {
        if (cursor >= arrayList.size()) {
            throw new NoSuchElementException();
        }
        return arrayList.get(cursor);
    }
}

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("chen");
        names.add("jian");
        names.add("seng");

        Iterator<String> iterator = new ArrayIterator<>(names);
        while (iterator.hasNext()) {
            System.out.println(iterator.currentItem());
            iterator.next();
        }
    }
}

在上面的视线中，需要将待遍历的容器对象，通过构造函数传递给迭代器类。实际上，为了封装迭代器的创建细节，我们可以在容器中定义一个迭代器的 iterator() 方法，来创建对应的迭代器。为了能基于接口而非实现编程，还需要将这个方法定义在 List 接口中。具体的代码实现和使用如下所示。

java 复制代码

public interface List<E> {
    Iterator iterator();
    // 省略其他接口函数...
}

public class ArrayList<E> implements List<E> {
    // ...
    @Override
    public Iterator iterator() {
        return new ArrayIterator(this);
    }
    // 省略其他代码...
}

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("chen");
        names.add("jian");
        names.add("seng");

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

对于 LinkedIterator，它结构和 ArrayIterator 完全相同，这里就不给出代码了。

结合刚刚的例子，来总结一下迭代器设计思路。

迭代器需要定义 hasNext()、currentItem()、next() 三个最基本的方法。
待遍历的容器对象通过依赖注入传递到迭代器类中。
容器通过 iterator() 方法来创建迭代器。

下面画了一张类图，你可以结合着看一看。

迭代器模式的优势

迭代器的原理和实现讲完了，现在，一起来看一下，使用迭代器遍历集合的优势。

一般来讲，遍历集合数据有三种方法：for 循环、foreach 循环、iterator 迭代器。对照这三种方式，举例说明下：

java 复制代码

List<String> names = new ArrayList<>();
names.add("chen");
names.add("jian");
names.add("seng");

// 第一种遍历方式，for循环
for (int i = 0; i < names.size(); i++) {
    System.out.print(names.get(i) + ",");
}

// 第二种遍历方式，foreach循环
for (String name : names) {
    System.out.print(name + ",");
}

// 第三种遍历方式，迭代器遍历
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next() + ","); // Java 中的迭代器接口是第二种定义方式，next()即移动游标又返回数据
}

实际上 foreach 循环只是一个语法糖而已，底层是基于迭代器来实现的。也就是说，上面的代码中的第二种遍历方式（foreach 循环）的底层实现，就是第三种遍历方式（迭代器遍历）。

从上面的代码来看，for 循环遍历方式比起迭代器遍历方式，代码看起来更加简洁。那为什么还要用迭代器来遍历容器呢？为什么还要给容器设计对应的迭代器呢？原因有三个。

首先，对于数组和链表这样的数据结构，遍历方式比较简单，直接使用 for 循环来遍历就足够了。但是，对于复杂的数据结构（比如树、图），有各种复杂的遍历方式。比如，树有前中后序、按层遍历，图有深度优先、广度优先遍历等等。如果由客户端来实现这些遍历算法，势必增加开发成本，而且容易写错。如果将这部分遍历的逻辑写到容器类中，也会导致容器类代码的复杂性。

前面讲过，应对复杂性的方法就是拆分。可以将遍历操作拆分到迭代器类中。比如，针对图的遍历，可以定义 DFSIterator、BFSIterator 两个迭代器类，让它们分别来实现深度优先和广度优先遍历。
其次，将游标指向的当前位置等信息，存储在迭代器类中，每个迭代器独享游标信息。这样，我们就可以创建多个不同的迭代器类，同时对同一个容器进行遍历而互不影响。
最后，容器和迭代器提供了抽象接口，方便在开发时，基于接口而非实现编程。当需要切换新的遍历算法时，比如，从前往后遍历链表切换成从后往前遍历链表，客户端只要将迭代器类从 LinkedIterator 切换为 ReversedLinkedIterator 即可，其他代码不需要修改。此外添加新的遍历算法，只需要扩展新的迭代器类，也更符合开闭原则。

总结

迭代器模式，也叫游标模式。它用来遍历集合对象。

这里说的 "集合对象"，也叫做 "容器" "聚合对象"，实际上就是包含一组对象的对象，比如数组、链表、树、图、跳表。

一个完整的迭代器模式，会设计容器和容器迭代器两部分。为了达到基于接口而非实现编程的目的，容器又包含容器接口、容器实现类，迭代器又包含迭代器接口和迭代器实现类。容器中需要定义 iterator() 方法，用来创建迭代器。迭代器接口中需要定义 hasNext()、next()、currentItem() 三个最基本的方法。容器对象通过依赖注入传递到迭代器类中。

遍历集合一般有 3 种方式：for 循环、foreach 循环、iterator 迭代器。后两种本质上属于一种，都可以看做迭代器遍历。相对于 for 循环，利用迭代器遍历有下面 3 个优势：

迭代器模式封装集合内部的复杂数据结构，开发者不需要了解如何遍历，直接使用容器提供的迭代器即可。
迭代器模式将集合对象的遍历操作从集合类中拆分出来，放到迭代器类中，让两者的职责更加单一。
迭代器模式让添加新的遍历算法更加容易，更符合开闭原则。此外，因为迭代器都实现自相同的接口，在开发中，基于接口而非实现编程，替换迭代器也变得更加容易。