一天学习一个设计模式之迭代器模式

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

当需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就应该考虑用迭代器模式，需要对聚集有多种方式遍历时，也可以考虑用迭代器模式。为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一接口。
迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器来负责，这样既可以做到不暴露集合的内部结构，又可让外部透明地访问集合内部的数据。

  

代码如下：

/**
 * 迭代器抽象类
 */
public abstract class Iterator {
    /**
     * 迭代方法：移动到第一个元素
     * @return
     */
    public abstract Object first();

    /**
     * 迭代方法：移动到下一个元素
     * @return
     */
    public abstract Object next();

    /**
     * 用于定义得到开始对象、得到下一个对象、判断
     * 是否到结尾、当前对象等抽象方法，统一接口
     * 迭代方法：是否为最后一个元素
     * @return
     */
    public abstract boolean isDone();

    /**
     * 迭代方法：返还当前元素
     * @return
     */
    public abstract Object currentItem();
}

/**
 * 具体迭代器类继承迭代器抽象类
 */
public class ConcreteIterator extends Iterator {

    /**
     * 定义了一个具体聚集对象
     */
    private ConcreteAggregate aggregate;
    private int current=0;

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

    /**
     * 得到聚集的第一个对象
     * @return
     */
    @Override
    public Object first() {
        return aggregate.getElement(0);
    }

    /**
     * 得到聚集的下一个对象
     * @return
     */
    @Override
    public Object next() {
        Object ret=null;
        current++;
        if (current<aggregate.getCount())
        {
            ret=aggregate.getCount();
        }
        return ret;
    }

    /**
     * 判断当前是否遍历到结尾，到结尾返回true
     * @return
     */
    @Override
    public boolean isDone() {
        return current>=aggregate.getCount()?true:false;
    }

    @Override
    public Object currentItem() {
        return aggregate.getElement(current);
    }
}

/**
 * 聚集抽象类
 */
public abstract class Aggregate {
    public abstract Iterator createIterator();
}

/**
 * 具体聚集类继承聚集抽象类
 */
public class ConcreteAggregate extends Aggregate {

    /**
     * 声明一个List泛型变量，用于存放聚合对象，用ArrayList同样可以实现
     */
    private List<Object> items=new ArrayList<>();

    public ConcreteAggregate(List<Object> list) {
        this.items=list;
    }

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }

    /**
     * 返回聚集总个数
     * @return
     */
    public int getCount() {
        return items.size();
    }

    /**
     * 取值方法：向外界提供聚集元素
     */
    public Object getElement(int index){
        if (index<getCount()){
            return items.get(index);
        }
        else {
            return null;
        }
    }
}

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

        List<Object> list=new ArrayList<>();
        list.add("大鸟");
        list.add("小菜");
        list.add("行李");
        list.add("老外");
        list.add("公交内部员工");
        list.add("小偷");

        ConcreteAggregate a=new ConcreteAggregate(list);
        Iterator i=a.createIterator();
        Object item=i.first();
        System.out.println("第1："+item.toString());
        while (!i.isDone()){
            System.out.println(i.currentItem()+"请买车票");
            i.next();
        }
    }
}