了解23种设计模式之迭代器模式

什么是迭代器模式

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

现实生活中： 你坐公交，售票员，每次都要去清点人数看有谁有没有买票，然后还规定，带箱子的必须买成人票。 这就是迭代器的基本思想。

当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑迭代器模式。

当你需要对聚集有多种方式遍历时，可以考虑用迭代器模式，为遍历不同的聚集结构提供如：开始，下一个，是否结束，当前哪一项等统一的接口。

在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。

既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：
暴露了聚合类的内部表示，使其数据不安全；
增加了客户的负担。
“迭代器模式”能较好地克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。

优点：
1，访问一个聚合对象的内容而无须暴露它的内部表示。
2，遍历任务交由迭代器完成，简化聚合类
3，它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
4，增加新的聚合类和迭代器都很方便，无须修改原有代码
4，封装性良好，为遍历不同的聚合结构提供一个统一的接口。

缺点：
增加了类的个数，这在一定程度上增加了系统的复杂性。

模式的结构

迭代器模式主要包含以下角色。
1，抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
2，具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
3，抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
4，具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

结构图如下：

代码的实现

1，抽象聚合（Aggregate）角色：创建迭代器对象的接口。

/**
 * @ClassName Aggregate
 * @Description 聚集抽象类
 * @Version 1.0
 **/
public abstract class Aggregate {

    /**
     * 创建一个迭代器
     * @return
     */
    public abstract  Iterator CreateIterator();
}

2，具体聚合（ConcreteAggregate）角色：实现抽象聚合类，定义根据下标获得对象、添加、返回聚集总数以及返回一个具体迭代器的实例。

/**
 * @ClassName ConcreateAggreate
 * @Description 具体的聚集器
 * @Version 1.0
 **/
public class ConcreateAggreate extends Aggregate{

    /**
     * 声明一个list,用于存放聚合对象，
     */
    private List<Object> items = new ArrayList<Object>();


    /**
     * 创建一个迭代器
     * @return
     */
    @Override
    public Iterator CreateIterator() {
        return new ConcreteIterator(this);
    }

    /**
     * 返回迭代器总数
     * @return
     */
    public int count() {
        return items.size();
    }

    /**
     * 添加对象
     * @param o
     */
    public void add(Object o) {
        items.add(o);
    }

    /**
     * 根据下标得到对象
     * @param
     */
    public Object get(int index) {
        return items.get(index);
    }
}

3，抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 isDone()、first()、next()、currentItem() 等方法。

/**
 * @ClassName Iterator
 * @Description 迭代器抽象类
 * @Version 1.0
 **/
public abstract class Iterator {

    /**
     * 用于定义得到对象，得到下个对象，判断是否得到结尾，当前对象等抽象方法，统一接口
     */
    public abstract  Object first();

    public abstract  Object next();

    public abstract  Boolean isDone();

    public abstract  Object currentItem();

}

4，具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

/**
 * @ClassName ConcreteIterator
 * @Description 具体的迭代器
 * @Version 1.0
 **/
public class ConcreteIterator extends Iterator{
    /**
     * 定义一个具体的聚集类
      */
    private ConcreateAggreate aggreate;

    private int current = 0;

    /**
     * 初始化传入一个聚集类
     * @param aggreate
     */
    public ConcreteIterator(ConcreateAggreate aggreate) {
        this.aggreate = aggreate;
    }

    /**
     * 得到第一个对象
     * @return
     */
    @Override
    public Object first() {
        return aggreate.get(0);
    }

    /**
     * 得到下一个对象
     * @return
     */
    @Override
    public Object next() {
        Object ret =null;
        current++;
        if(current<aggreate.count()){
            ret = aggreate.get(current);
        }
        return ret;
    }

    /**
     * 得到最后一个
     * @return
     */
    @Override
    public Boolean isDone() {
        return current>= aggreate.count() ? true : false;
    }

    /**
     * 返回当前的聚集类
     * @return
     */
    @Override
    public Object currentItem() {
        return aggreate.get(current);
    }
}

测试

public class MainClass {
    public static void main(String[] args) {

        ConcreateAggreate aggreate = new ConcreateAggreate();
        aggreate.add("张三");
        aggreate.add("王五");
        aggreate.add("李四");
        aggreate.add("马超");
        aggreate.add("关羽");
        aggreate.add("刘备");

        Iterator iterator  = new ConcreteIterator(aggreate);

        Object item  = iterator.first();

        while (!iterator.isDone()){
            System.out.println(iterator.currentItem().toString()+"请买车票!!");
            iterator.next();
        }
    }
}