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

迭代器模式的结构图

迭代器模式中的角色：

• Iterator：迭代抽象类，用于定义得到开始对象，得到下一个对象、判断是否到结尾、当前对象等抽象方法，统一接口。
• ConcreteIterator：具体迭代器类，继承 Iterator，实现开始、下一个，是否结尾、当前对象等方法。
• Aggregate：聚集抽象类。
• ConcreteAggregate：具体聚集类，继承 Aggregate。

迭代器模式的具体实现

（1）迭代抽象类

public interface Iterator {

    public Object first();

    public Object next();

    public boolean isDone();

    public Object currentItem();
}

（2）具体迭代器类

public class ConcreteIterator implements Iterator {

    private ConcreteAggregate concreteAggregate;
    private int current = 0;

    public ConcreteIterator(ConcreteAggregate concreteAggregate) {
        this.concreteAggregate = concreteAggregate;
    }

    @Override
    public Object first() {
        return concreteAggregate.item(0);
    }

    @Override
    public Object next() {
        Object ret = null;
        current++;
        if (current < concreteAggregate.count()) {
            ret = concreteAggregate.item(current);
        }
        return ret;
    }

    @Override
    public boolean isDone() {
        return current >= concreteAggregate.count();
    }

    @Override
    public Object currentItem() {
        return concreteAggregate.item(current);
    }
}

（3）聚集抽象类

public interface Aggregate {

    public Iterator createIterator();
}

（4）具体聚集类

public class ConcreteAggregate implements Aggregate {

    private Object[] objectList;
    private int size = 0;
    private int index = 0;

    public ConcreteAggregate() {
        index = 0;
        size = 0;
        objectList = new Object[100];
    }

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }

    public void add(Object obj) {
        objectList[index++] = obj;
        size++;
    }

    public int count() {
        return size;
    }

    public Object item(int index) {
        return objectList[index];
    }
}

（5）客户端调用

public class Client {
    public static void main(String[] args) {
        ConcreteAggregate concreteAggregate = new ConcreteAggregate();

        concreteAggregate.add("BB");
        concreteAggregate.add("AA");
        concreteAggregate.add("CC");
        concreteAggregate.add("DD");

        Iterator iterator = new ConcreteIterator(concreteAggregate);
        Object item = iterator.first();

        while (!iterator.isDone()) {
            System.out.println(iterator.currentItem());
            iterator.next();
        }
    }
}

（6）输出

BB
AA
CC
DD

迭代器模式的优缺点

优点：
简化了遍历方式，对于对象集合的遍历，还是比较麻烦。
可以提供多种遍历方式，如有序列表。
封装性好，用户需要得到遍历器就可以遍历，对于遍历算法不需要关系。

缺点：
对于简单的遍历，如数组或者有序列表，使用迭代器方式遍历较为方所而且遍历效率不高，使用迭代器的方式比较适合哪些底层以链表形式实现的集合。