迭代器模式详解

1.简介

在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方式就必须修改程序源代码，这违背了“开闭原则”。
既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：

1. 暴露了聚合类的内部表示，使其数据不安全；
2. 增加客户的负担。

“迭代器模式”能较好地客服以上缺点，它在客户访问类和聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”，如Java中的Collection、List、Set、Map等都包含了迭代器。
迭代器模式在生活中应用的比较广泛，比如：物流系统中的传送带，不管传送的是什么物品，都会被打包成一个个箱子，并且有一个统一的二维码。这样我们不需要关心箱子里是什么，在分发时只需要一个个检查发送的目的地即可。再比如，我们平时乘坐交通工具，都是同一刷卡或者刷脸进站，而不需要关心是男性还是女性、是残疾人还是正常人等信息。

2.定义

迭代器（Iterator）模式的定义：提供一个对象来顺序访问聚合对象中的一些列数据，而不暴露聚合对象的内部表示。

3.优点

1. 访问一个聚合对象的内容而无须暴露它的内部表示。
2. 遍历任务交由迭代器完成，这简化了聚合类。
3. 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
4. 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
5. 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

4.缺点

增加了类的个数，这在一定程度上增加了系统的复杂性。

5.结构

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。
迭代器模式主要包含以下角色：

1. 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
2. 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
3. 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含hasNext()、first()、next()等方法。
4. 具体迭代器（ConcreteIterator）角色：实现抽象迭代器接口中定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

结构图如下：

6.应用场景

1. 当需要为聚合对象提供多种遍历方式时。
2. 当需要为遍历不同的聚合结构提供一个统一的接口时。
3. 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

7.代码样例

1.简单样例

/**
 * 抽象聚合
 */
interface Aggregate{
    void add(Object obj);
    void remove(Object obj);
    Iterator getIterator();
}

/**
 * 具体聚合
 */
class ConcreteAggregate implements Aggregate{
    private List<Object> list = new ArrayList();
    @Override
    public void add(Object obj) {
        list.add(obj);
    }

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }

    @Override
    public Iterator getIterator() {
        return new ConcreteIterator(list);
    }
}
/**
 * 抽象迭代器
 */
interface Iterator{
    Object first();
    Object next();
    boolean hasNext();
}

/**
 * 具体迭代器
 */
class ConcreteIterator implements Iterator{
    private List<Object> list = null;
    private int index = -1;
    public ConcreteIterator(List<Object> list) {
        this.list = list;
    }

    @Override
    public Object first() {
        index = 0;
        return list.get(index);
    }

    @Override
    public Object next() {
        return this.hasNext() ? list.get(++index) : null;
    }

    @Override
    public boolean hasNext() {
        return index < (list.size() - 1);
    }
}
public class IteratorSimpleTest {
    public static void main(String[] args){
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add("中山大学");
        aggregate.add("华南理工");
        aggregate.add("韶关学院");
        System.out.println("聚合的内容有：");
        Iterator it = aggregate.getIterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("first：" + it.first());
    }
}

2.应用实例

例：用迭代器模式编写一个浏览婺源旅游风景图地程序。
分析：婺源的名胜古迹较多，要设计一个查看相关景点图片和简介的程序，用“迭代器模式”设计比较合适。
首先，设计一个婺源景点（WyViewSpot）类来保存每张图片的名称与简介；再设计一个景点集（ViewSpotSet）接口，它是抽象聚合类，提供了增加和删除婺源景点的方法，以及获取迭代器的方法。
然后，定义一个婺源景点集（WyViewSpotSet）类，它是具体聚合类，用ArrayList来保存所有景点信息，并实现父类中的抽象方法；再定义婺源景点的抽象迭代器（ViewSpotIterator）接口，其中包含了查看景点信息的相关方法。
最后，定义婺源景点的具体迭代器（WyViewSpotIterator）类，它实现了父类的抽象方法；客户端程序设计成窗口程序，它初始化婺源景点集（ViewSpotSet）中的数据，并实现ActionListener接口，它通过婺源景点迭代器（ViewSpotIterator）来查看婺源景点（WyViewSpot）的信息。
结构图如下：

代码样例：

/**
 * 婺源景点类
 */
@Getter
@AllArgsConstructor
class WyViewSpot{
    private String name;
    private String introduce;
}

/**
 * 抽象迭代器
 */
interface ViewSpotIterator{
    boolean hasNext();
    WyViewSpot first();
    WyViewSpot next();
    WyViewSpot previous();
    WyViewSpot last();
}

/**
 * 具体迭代器：婺源景点迭代器
 */
class WyViewSpotIterator implements ViewSpotIterator{
    private ArrayList<WyViewSpot> list = null;
    private int index = -1;
    public WyViewSpotIterator(ArrayList<WyViewSpot> list){
        this.list = list;
    }
    @Override
    public boolean hasNext() {
        return index < list.size() - 1;
    }

    @Override
    public WyViewSpot first() {
        index = 0;
        return list.get(index);
    }

    @Override
    public WyViewSpot next() {
        return this.hasNext() ? list.get(++index) : null;
    }

    @Override
    public WyViewSpot previous() {
        return index > 0 ? list.get(--index) : null;
    }

    @Override
    public WyViewSpot last() {
        return list.get(list.size() - 1);
    }
}

/**
 * 抽象聚合：婺源景点集接口
 */
interface ViewSpotSet{
    void add(WyViewSpot obj);
    void remove(WyViewSpot obj);
    ViewSpotIterator getIterator();
}

/**
 * 具体聚合：婺源景点集
 */
class WyViewSpotSet implements ViewSpotSet{
    private ArrayList<WyViewSpot> list = new ArrayList<>();
    @Override
    public void add(WyViewSpot obj) {
        list.add(obj);
    }

    @Override
    public void remove(WyViewSpot obj) {
        list.remove(obj);
    }

    @Override
    public ViewSpotIterator getIterator() {
        return new WyViewSpotIterator(list);
    }
}

/**
 * 相框类
 */
class PictureFrame extends JFrame implements ActionListener{
    ViewSpotSet set;
    ViewSpotIterator iterator;
    WyViewSpot spot;
    PictureFrame(){
        super("中国最美乡村“婺源”的部分风景图");
        this.setResizable(false);
        set = new WyViewSpotSet();
        set.add(new WyViewSpot("江湾", "江湾景区是婺源的一个国家5A级旅游景区，景区内有萧江宗祠、永思街、滕家老屋、婺源人家、乡贤园、百工坊等一大批古建筑，精美绝伦，做工精细。"));
        set.add(new WyViewSpot("李坑", "李坑村是一个以李姓聚居为主的古村落，是国家4A级旅游景区，其建筑风格独特，是著名的徽派建筑，给人一种安静、祥和的感觉。"));
        set.add(new WyViewSpot("思溪延村", "思溪延村位于婺源县思口镇境内，始建于南宋庆元五年（1199年），当时建村者俞氏以（鱼）思清溪水而名。"));
        set.add(new WyViewSpot("晓起村", "晓起有“中国茶文化第一村”与“国家级生态示范村”之美誉，村屋多为清代建筑，风格各具特色，村中小巷均铺青石，曲曲折折，回环如棋局。"));
        set.add(new WyViewSpot("菊径村", "菊径村形状为山环水绕型，小河成大半圆型，绕村庄将近一周，四周为高山环绕，符合中国的八卦“后山前水”设计，当地人称“脸盆村”。"));
        set.add(new WyViewSpot("篁岭", "篁岭是著名的“晒秋”文化起源地，也是一座距今近六百历史的徽州古村；篁岭属典型山居村落，民居围绕水口呈扇形梯状错落排布。"));
        set.add(new WyViewSpot("彩虹桥", "彩虹桥是婺源颇有特色的带顶的桥——廊桥，其不仅造型优美，而且它可在雨天里供行人歇脚，其名取自唐诗“两水夹明镜，双桥落彩虹”。"));
        set.add(new WyViewSpot("卧龙谷", "卧龙谷是国家4A级旅游区，这里飞泉瀑流泄银吐玉、彩池幽潭碧绿清新、山峰岩石挺拔奇巧，活脱脱一幅天然泼墨山水画。"));
        iterator = set.getIterator();
        spot = iterator.first();
        this.showPicture(spot.getName(), spot.getIntroduce());

    }
    void showPicture(String name, String introduce){
        Container container = this.getContentPane();
        JPanel picturePanel = new JPanel();
        JPanel controlPanel = new JPanel();
        String fileName = "src/iterator/picture/" + name + ".jpg";
        JLabel lb = new JLabel(name, new ImageIcon(fileName), JLabel.CENTER);
        JTextArea textArea = new JTextArea(introduce);
        lb.setHorizontalTextPosition(JLabel.CENTER);
        lb.setVerticalTextPosition(JLabel.TOP);
        lb.setFont(new Font("宋体", Font.BOLD, 20));
        textArea.setLineWrap(true);
        textArea.setEnabled(false);
        picturePanel.setLayout(new BorderLayout(5, 5));
        picturePanel.add("Center", lb);
        picturePanel.add("South", textArea);
        JButton first, last, next, previous;
        first = new JButton("第一张");
        next = new JButton("下一张");
        previous = new JButton("上一张");
        last = new JButton("最末张");
        first.addActionListener(this);
        next.addActionListener(this);
        previous.addActionListener(this);
        last.addActionListener(this);
        controlPanel.add(first);
        controlPanel.add(next);
        controlPanel.add(previous);
        controlPanel.add(last);
        container.add("Center", picturePanel);
        container.add("South", controlPanel);
        this.setSize(630, 550);
        this.setVisible(true);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        String command = e.getActionCommand();
        if(command.equals("第一张")){
            spot = iterator.first();
        }else if(command.equals("下一张")){
            spot = iterator.next();
        }else if(command.equals("上一张")){
            spot = iterator.previous();
        }else if(command.equals("最末张")){
            spot = iterator.last();
        }
        this.showPicture(spot.getName(), spot.getIntroduce());
    }
}
public class IteratorWyViewTest {
    public static void main(String[] args){
        new PictureFrame();
    }
}

3.迭代器模式的扩展

迭代器模式常常与组合模式结合起来使用，在对组合模式中的容器构件进行访问时，经常将迭代器潜藏在组合模式的容器构成类中。当然，也可以构造一个外部迭代器来对容器构件进行访问。
结构图如下：

代码样例：

interface Component{
    void operation();
}
class LeafA implements Component{
    @Override
    public void operation() {
        System.out.println("叶子节点A进行操作！");
    }
}
class LeafB implements Component{
    @Override
    public void operation() {
        System.out.println("叶子节点B进行操作！");
    }
}
class Composite implements Component{
    private List<Component> list = new ArrayList<>();
    public void add(Component component){
        list.add(component);
    }
    public void remove(Component component){
        list.remove(component);
    }
    public Component getChild(int i){
        return list.get(i);
    }
    @Override
    public void operation() {
        for(Component component : list){
            component.operation();
        }
    }
    public Iterator getIterator(){
        return new ConcreteIterator(list);
    }
}
interface Iterator{
    Component first();
    Component next();
    boolean hasNext();
}
class ConcreteIterator implements Iterator{
    private List<Component> list = null;
    private int index;
    public ConcreteIterator(List<Component> list){
        this.list = list;
        index = -1;
    }
    @Override
    public Component first() {
        index = 0;
        return list.get(index);
    }

    @Override
    public Component next() {
        return hasNext() ? list.get(++index) : null;
    }

    @Override
    public boolean hasNext() {
        return index < list.size() - 1;
    }
}
public class IteratorAndCompositeTest {
    public static void main(String[] args){
        Component leafA = new LeafA();
        Component leafB = new LeafB();
        Composite composite = new Composite();
        composite.add(leafA);
        composite.add(leafB);

        composite.operation();
        System.out.println("------------------");
        Iterator iterator = composite.getIterator();
        while(iterator.hasNext()){
            iterator.next().operation();
        }
    }
}

4.迭代器模式在JDK源码中的应用

Iterator是Java提供的迭代器，可以让某个序列实现该接口来提供标准的Java迭代器。也就是说，实现Iterator接口就相当于“使用”一个迭代器。
Iterator接口源码如下：

public interface Iterator<E> {
   
    boolean hasNext();    // 判断是否存在下一个对象元素
    E next();
   
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

从上面代码可以看出，Iterator接口定义了一些需要子类实现的方法和默认方法。其中包含了两个主要方法，即hasNext()和next()方法。代码中两个default方法是JDK1.8之后才有的接口新特性。JDK1.8版本之前接口不能有方法实体。
另外，我们在学习组合模式时见过remove()方法。可以看出迭代器模式和组合模式两者存在一定的相似性，组合模式解决的是统一树形结构各层次访问接口，迭代器模式解决的是统一各集合对象元素遍历接口。虽然它们的适配场景不同，但核心理念是相同的。
接着来看Iterator的实现类，以ArrayList为例，ArrayList实现了List接口，List接口继承了Collection接口，Collection接口继承了Iterable接口，Iterable接口中包含了一个iterator方法，因此ArrayList就需要实现该iterator()方法。该方法的实现很简单，就是返回一个实现了Iterator接口的迭代器实例。
ArrayList类中的迭代器是以内部类的形式实现的，由于内部类可以直接访问外部类的成员变量，所以该迭代器内部类可以很方便地实现Iterator接口中的hasNext()和next()方法。ArrayList中的迭代器内部类名字为Itr。
源码如下：

package java.util;

import java.util.function.Consumer;

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
...
transient Object[] elementData;
private int size;

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        Itr() {}

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
        ...
    }
    ...
}

Itr是ArrayList中实现了Iterator接口的内部类，且在实现hasNext()和next()方法时，可以很方便地访问ArrayList的成员变量size和elementData数组。
在ArrayList内部还有几个迭代器对Iter进行了进一步扩展，首先看ListItr。

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

    public boolean hasPrevious() {
        return cursor != 0;
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor - 1;
    }
    ...
}

ListItr内部类增加了hasPrevious()方法，主要用于判断是否还有上一个元素。另外，还有SubList对子集合的迭代处理。

5.迭代器模式在MyBatis源码中的应用

迭代器模式在Mybatis中也是必不可少的，下面来看DefaultCursor类，源码如下：

public class DefaultCursor<T> implements Cursor<T> {
    ...
    private final CursorIterator cursorIterator = new CursorIterator();
    ...
}

DefaultCursor实现了Cursor接口，且定义了一个成员变量cursorIterator，其类型为CursorIterator。
继续查看CursorIterator类的源码实现，它是DefaultCursor的一个内部类，实现了JDK中的Iterator接口，源码如下：

private class CursorIterator implements Iterator<T> {
    T object;
    int iteratorIndex;

    private CursorIterator() {
        this.iteratorIndex = -1;
    }

    public boolean hasNext() {
        if (this.object == null) {
            this.object = DefaultCursor.this.fetchNextUsingRowBound();
        }

        return this.object != null;
    }

    public T next() {
        T next = this.object;
        if (next == null) {
            next = DefaultCursor.this.fetchNextUsingRowBound();
        }

        if (next != null) {
            this.object = null;
            ++this.iteratorIndex;
            return next;
        } else {
            throw new NoSuchElementException();
        }
    }

    public void remove() {
        throw new UnsupportedOperationException("Cannot remove element from Cursor");
    }
}

8.思维导图