模式定义

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

模式结构

模式结构

Iterator:迭代器接口。定义访问和遍历元素的接口。

ConcreteIterator:具体的迭代器实现对象。实现对聚合对象的遍历，并跟踪遍历时的当前位置。

Aggregate:聚合对象。定义创建相应迭代器对象的接口。

ConcreteAggregate:具体聚合对象。实现创建相应的迭代器对象。

代码实现

public abstract class Aggregate {

    public abstract Iterator CreateIterator();
}

class ConcreteAggregate extends Aggregate {
    private String[] ss = null;

    public ConcreteAggregate(String[] ss) {
        this.ss = ss;
    }

    public Iterator CreateIterator() {
        return new ConcreteIterator(this);
    }

    public Object get(int index) {
        Object object = null;
        if (index < ss.length) {
            object = ss[index];
        }
        return object;
    }

    public int size() {
        return this.ss.length;
    }
}

public interface Iterator {
    public void first();
    public void next();
    public Object currentItem();
    public boolean idDone();
}

class ConcreteIterator implements Iterator {
    private int index = -1;
    private ConcreteAggregate aggregate;

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

    public void first() {
        index = 0;
    }

    public void next() {
        if (index < this.aggregate.size()) {
            index = index + 1;
        }
    }

    public Object currentItem() {
        return this.aggregate.get(index);
    }

    public boolean idDone() {
        if(index == this.aggregate.size()){
            return true;
        }
        return false;
    }
}

public class Client {
    public static void main(String[] args) {
        String[] names = {"1", "2", "3"};
        Aggregate aggregate = new ConcreteAggregate(names);
        Iterator iterator = aggregate.CreateIterator();
        iterator.first();
        while (!iterator.idDone()) {
            Object obj = iterator.currentItem();
            System.out.println(obj);
            iterator.next();
        }
    }
}

模式的优缺点

优点

1. 它支持以不同的方式遍历一个聚合对象。

2. 迭代器简化了聚合类。

3. 在同一个聚合上可以有多个遍历。

4. 在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

思考

模式本质：控制访问聚合对象中的元素。

开发中的应用场景

1. 访问一个聚合对象的内容而无须暴露它的内部表示。

2. 需要为聚合对象提供多种遍历方式。

3. 为遍历不同的聚合结构提供一个统一的接口。