什么是迭代器模式

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

模式角色

Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。

● ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。

● Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。

● ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

UML类图

迭代器模式

代码实现

public interface Iterator<T> {

    // 返回第一位元素
    T first();
    // 返回最后一位
    T last();

    //返回该对象的下一个元素
    T next();

    //判断该对象有没有下一个元素
    boolean hasNext();

    // 获取当前元素
    T currentItem();

}

public class ConcreteIterator<T> implements Iterator<T> {

    List<T> list;

    //定义一个游标，用于记录当前访问位置
    private int cursor;

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

    @Override
    public T first() {
        return list.get(0);
    }

    @Override
    public T last() {
        return list.get(list.size() - 1);
    }

    @Override
    public T next() {
        T t = null;

        if (this.hasNext()) {
            t = list.get(cursor++);
        }
        return t;
    }

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

    @Override
    public T currentItem() {
        return list.get(cursor);
    }
}

public interface Aggregate<T> {

    void add(T t);
    void remove(T t);
    //生成遍历器
    Iterator<T> createIterator();
}

public class ConcreateAggregate <T> implements Aggregate<T> {

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

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

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

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

public class Client {

    public static void main(String[] args) {
        ConcreateAggregate<String> aggregate = new ConcreateAggregate<>();
        aggregate.add("a");
        aggregate.add("v");
        aggregate.add("s");
        aggregate.add("d");

        Iterator<String> iterator = aggregate.createIterator();
        System.out.println("第一个是：" + iterator.first());
        System.out.println("最后一个是：" + iterator.last());
        System.out.println("当前的元素是: " + iterator.currentItem());
        while (iterator.hasNext()) {
            System.out.println("下一个是：" + iterator.next());
        }
    }
}

优点

• 简化了遍历方式，对于对象集合的遍历，还是比较麻烦的，对于数组或者有序列表，我们尚可以通过游标来取得，但用户需要在对集合了解很清楚的前提下，自行遍历对象，但是对于hash表来说，用户遍历起来就比较麻烦了。而引入了迭代器方法后，用户用起来就简单的多了。
• 可以提供多种遍历方式，比如说对有序列表，我们可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历了。
• 封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。
  缺点
• 对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐，大家可能都有感觉，像ArrayList，我们宁可愿意使用for循环和get方法来遍历集合。
  迭代器模式完整代码