迭代器模式

 当你需要对聚集有多种方式遍历时，可以考虑用迭代器模式。

迭代器模式（Iterator）就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以不暴露集合的内部结构，

又可让外部代码透明的访问集合内部数据

代码示例：

/**
 * Iterator:迭代器抽象类
 * 用于定义得到开始对象，得到下一对象，判断是否结尾，当前对象
 * 等抽象方法的统一接口
 */
public abstract class Iterator {
    public abstract Object first();
    public abstract Object next();
    public abstract boolean isDone();
    public abstract Object currentItem();
}

 

public class ConcreteIterator extends Iterator{
    private ConcreteAggregate aggregate;  //定义一个具体的聚集对象
    private int current = 0;
    
    /**
     * 初始化时将具体聚集对象传入
     * @param aggregate
     */
    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

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

    @Override
    public Object next() {
        Object ret = null;
        current++;
        if(current<aggregate.count()){
            ret = aggregate.thisObject(current);
        }
        return ret;
    }

    @Override
    public boolean isDone() {
        return current>=aggregate.count()?true:false;
    }

    @Override
    public Object currentItem() {
        // TODO Auto-generated method stub
        return aggregate.thisObject(current);
    }

    public ConcreteAggregate getAggregate() {
        return aggregate;
    }

    public void setAggregate(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    public int getCurrent() {
        return current;
    }

    public void setCurrent(int current) {
        this.current = current;
    }

    
}

/**
 *Aggregate:聚集抽象类
 */
public abstract class Aggregate {
    public abstract Iterator createIterator();//创建迭代器
}

import java.util.ArrayList;
import java.util.List;

public class ConcreteAggregate extends Aggregate{
    //声明一个List变量，用于存放聚合对象
    private List<Object> items = new ArrayList<Object>();
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
    
    /**
     * 返回聚集总个数
     */
    public  int count(){
        return items.size();
    }
    
    /**
     * 声明一个搜索器
     * @param index
     * @return
     */
    public Object thisObject(int index){
        return items.get(index);
    }
    /**
     * 添加聚合对象
     */
    public void add(Object obj){
        items.add(obj);
    }

}

public class IteratorTest {

    public static void main(String[] args) {
        //聚集对象：-->公交车
        ConcreteAggregate agg = new ConcreteAggregate();
        agg.add("大鸟");
        agg.add("小菜");
        agg.add("行李");
        agg.add("老外");
        agg.add("内部员工");
        agg.add("小偷");

        Iterator it = new ConcreteIterator(agg);
        while(!it.isDone()){
            System.out.println(it.currentItem()+"  请买票");
            it.next();
        }
    }

}

大鸟  请买票
小菜  请买票
行李  请买票
老外  请买票
内部员工  请买票
小偷  请买票