设计模式之迭代器模式

1. 定义

提供一种方法访问一个容器对象中各个元素，而又不暴露该对象的内部细节。

2. 作用

在遍历集合的时候，把在元素之间游走的责任交给迭代器，而不是集合。

3. 结构

抽象容器
一般是一个接口，提供一个 iterator() 方法，例如 Java 中的 Collection 接口。
具体容器
就是抽象容器的具体实现类，比如 List 接口的实现有序列表 ArrayList，List 接口的链表实现 LinkList，Set 接口的哈希列表的实现 HashSet 等。
抽象迭代器
定义遍历元素所需要的方法，一般会有两个方法：取得下一个元素的方法 next()，判断是否遍历结束的方法 hasNext()，移出当前对象的方法 remove()。
具体迭代器
实现迭代器接口中定义的方法，完成集合的迭代。

4. 实现

类图

抽象容器接口，可以当作 Collection 接口的简化版。

public interface Aggregate<E> {
    /**
     * 添加元素
     *
     * @param data
     */
    void add(E data);

    /**
     * 移除元素
     *
     * @param data
     */
    void remove(E data);

    /**
     * 迭代器
     *
     * @return
     */
    Iterator<E> iterator();
}

迭代器接口，类似 Java 内置的迭代器。

public interface Iterator<E> {
    /**
     * 是否存在下一个元素
     *
     * @return
     */
    boolean hasNext();

    /**
     * 获取下一个元素
     *
     * @return
     */
    E next();
}

具体容器和迭代器，这里使用 ArrayList 作为内部存储，迭代器顺序遍历集合。

public class ConcreteAggregate<E> implements Aggregate<E> {
    private List<E> list = new ArrayList<>();

    @Override
    public void add(E data) {
        list.add(data);
    }

    @Override
    public void remove(E data) {
        list.remove(data);
    }

    @Override
    public Iterator<E> iterator() {
        return new InnerIterator();
    }

    /**
     * 迭代器
     */
    private class InnerIterator implements Iterator<E> {
        private int cursor;

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

        @Override
        public E next() {
            E data = list.get(cursor);
            cursor++;
            return data;
        }
    }
}

测试，使用起来和 Java 内置的集合是不是很像。

    public static void main(String args[]) {
        Aggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.add("小刘");
        aggregate.add("小李");
        aggregate.add("小王");

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

5. 优缺点

1. 优点
迭代器简化了遍历一个聚合对象的方式，在同一个聚合上可以有多个遍历。在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

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

3. 使用场景
迭代器模式是与集合共存的。一般来说，我们只要实现一个集合，就需要同时提供这个集合的迭代器，就像 Java 中的 Collection、Set、Map 等，这些集合都有自己的迭代器。假如我们要实现一个这样的新容器，当然也需要引入迭代器模式，给我们的容器添加一个迭代器。

参考文章：
迭代器模式