（十九）迭代器模式

1. 概述

迭代器模式（Iterator)，提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

当需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就应该考虑用迭代器模式。
当需要对聚集有多种方式遍历时，可以考虑用迭代器模式。
迭代器为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。

2.示例

Iterator 迭代器抽象类。
Iterator.java

public abstract class Iterator {
    // 用于定义得到开始对象、得到下一个对象、
    // 判断是否到结尾、当前对象等抽象方法，统一接口
    public abstract Object first();
    public abstract Object next();
    public abstract boolean isDone();
    public abstract Object currentItem();
}

Aggregate 聚集抽象类。
Aggregate.java

public abstract class Aggregate {
    // 创建迭代器
    public abstract Iterator createIterator();
}

Concretelterator 具体迭代器类，继承 Iterator。
ConcreteIterator.java

public class ConcreteIterator extends Iterator{
    // 定义了一个具体聚集对象
    private ConcreteAggregate aggregate;
    private int current = 0;

    // 初始化时将具体的聚集对象传入
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    // 得到聚集的第一个对象
    @Override
    public Object first() {
        return aggregate.get(0);
    }

    // 得到聚集的下一个对象
    @Override
    public Object next() {
        Object ret = null;
        current++;
        if (current < aggregate.count()) {
            ret = aggregate.get(current);
        }
        return ret;
    }

    // 判断当前是否遍历到结尾，到结尾返回 true
    @Override
    public boolean isDone() {
        return current >= aggregate.count();
    }

    // 返回当前的聚集对象
    @Override
    public Object currentItem() {
        return aggregate.get(current);
    }
}

ConcreteAggregate 具体聚集类继承 Aggregate。
ConcreteAggregate.java

public class ConcreteAggregate extends Aggregate{
    // 存放聚合对象
    private List items = new ArrayList();
    // 返回聚集总个数
    public int count() {
        return items.size();
    }
    // 返回索引对象
    Object get(int i) {
        return items.get(i);
    }
    // 添加对象
    void add(Object o) {
        items.add(o);
    }
    @Override
    public Iterator createIterator() {
        return null;
    }
}

客户端代码。
Client.java

public class Client {
    public static void main(String[] args) {
        ConcreteAggregate a = new ConcreteAggregate();
        a.add("A");
        a.add("B");
        a.add("C");
        a.add("D");
        a.add("E");
        ConcreteIterator i = new ConcreteIterator(a);
        Object o = i.first();
        while (!i.isDone()) {
            System.out.println(i.currentItem());
            i.next();
        }
    }
}

输出如下。

A
B
C
D
E

Process finished with exit code 0

3.总结

迭代器（Iterator）模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。