迭代器模式——解决问题的第三者

（《设计模式解析与实战——何红辉，关爱民》读书笔记）

这个模式对开发者来说几乎不会自己去实现一个迭代器。所以对于这个模式更多的是在于理会其思想，而非应用。

一、定义
提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。

二、使用场景
遍历一个容器对象

三、迭代器模式的通用模式代码

/**
 * 迭代器接口：负责定义、访问和遍历元素的接口
 * 
 * @param <T>
 */
public interface Iterator<T> {

    /**
     * 是否还有下一个对象
     * 
     * @return true:有; false:没有
     */
    boolean hasNext();

    /**
     * @return 返回当前位置的元素并将位置移至下一位
     */
    T next();
}

/**
 * 具体迭代器类：实现迭代器接口，并记录遍历的当前位置
 * 
 * @param <T>
 */
public class ConcreteIterator<T> implements Iterator<T> {

    private List<T> list = new ArrayList<T>();
    private int cursor = 0;

    public ConcreteIterator(List<T> list) {
        super();
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return cursor != list.size();
    }

    @Override
    public T next() {
        T obj = null;
        if (this.hasNext()) {
            obj = this.list.get(cursor++);
        }
        return obj;
    }
}

/**
 * 容器接口：负责提供创建具体迭代器角色的接口
 * 
 * @param <T>
 */
public interface Aggregate<T> {
    /**
     * 添加一个元素
     * 
     * @param obj
     *            元素对象
     */
    void add(T obj);

    /**
     * 移除一个元素
     * 
     * @param obj
     *            元素对象
     */
    void remove(T obj);

    /**
     * 获取容器的迭代器
     * 
     * @return 迭代器对象
     */
    Iterator<T> iterator();
}

/**
 * 具体容器类：具体迭代器角色与该容器相关联
 * 
 * @param <T>
 */
public class ConcreteAggregate<T> implements Aggregate<T> {

    private List<T> list = new ArrayList<>();

    @Override
    public void add(T obj) {
        list.add(obj);

    }

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

    }

    @Override
    public Iterator<T> iterator() {
        return new ConcreteIterator<>(list);
    }
}

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        Aggregate<String> a = new ConcreteAggregate<>();
        a.add("hello1");
        a.add("hello2");
        a.add("hello3");
        a.add("hello4");
        a.add("hello5");

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

运行结果：

四、总结
优点：
支持以不同的方式去遍历一个容器对象，也可以有多个遍历，弱化了容器类与遍历算法之间的关系；
缺点：
对类文件的增加。