Iterator

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

当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你应该考虑迭代模式。为遍历不同的聚集结构提供如 开始、下一个、是否结束、目前哪一个 等统一接口。

迭代模式分离了对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部数据。

public abstract class Iterator {
    //用于定义得到开始对象，得到下一个对象，是否到结尾，当前对象等方法，统一接口。
    public abstract Object getFirst();
    public abstract Object next();
    public abstract boolean isDone() ;
    public abstract Object getCurrentItem();
}

public abstract class Aggregate {
    //创建迭代器
    public abstract Iterator createIterator();
}

public class ConcreteAggregate extends Aggregate{
    
    //声明一个List变量，用于存放聚合对象。
    private List<Object> items = new ArrayList<Object>();
    
    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
    
    //返回聚集总个数
    public Object getItem(int index){
        return items.get(index);
    }
    
    public void setItem(int index, Object obj){
        items.add(index, obj);
    }
    
    public void setItem(Object obj){
        items.add(obj);
    }
    
    public int getCount(){
        return items.size() ;
    }
}

public class ConcreteIterator extends Iterator{

    //定义一个具体聚集对象
    private ConcreteAggregate aggregate ;
    private int current = 0 ;
    
    public ConcreteIterator(ConcreteAggregate aggregate){
        this.aggregate = aggregate ;
    }
    
    @Override //得到当前对象
    public Object getCurrentItem() {
        return aggregate.getItem(current);
    }

    @Override  //得到第一个对象
    public Object getFirst() {
        return aggregate.getItem(0);
    }

    @Override  //是否已结尾
    public boolean isDone() {
        return current >= aggregate.getCount() ? true : false ;
    }

    @Override  //得到下一对象
    public Object next() {
        Object obj = null ;
        current ++ ;
        if(current < aggregate.getCount()){
            obj = aggregate.getItem(current);
        }
        return obj;
    }
    
}

public class ConcreteIteratorDec extends Iterator{

    private ConcreteAggregate aggregate ;
    private int current = 0 ;
    
    public ConcreteIteratorDec(ConcreteAggregate aggregate){
        this.aggregate = aggregate ;
        current = aggregate.getCount() -1 ;
    }
    
    @Override
    public Object getCurrentItem() {
        return aggregate.getItem(current);
    }

    @Override
    public Object getFirst() {
        return aggregate.getItem(aggregate.getCount() -1);
    }

    @Override
    public boolean isDone() {
        return current < 0 ? true : false ;
    }

    @Override
    public Object next() {
        Object obj = null ;
        current -- ;
        if(current >= 0){
            obj = aggregate.getItem(current);
        }
        return obj;
    }
    
}

    public static void main(String[] args) {
        
        ConcreteAggregate agg = new ConcreteAggregate();
        
        agg.setItem("abc");
        agg.setItem("小花");
        agg.setItem("阿猫");
        agg.setItem("阿狗");
        agg.setItem("小草");
        agg.setItem("菊花");
        agg.setItem("efg");
        
        //从头到尾遍历
        //Iterator iterator = new ConcreteIterator(agg);
        //从尾到头遍历
        Iterator iterator = agg.createIterator();
        
        Object obj1 = iterator.getFirst();
        
        while(!iterator.isDone()){
            System.out.println(iterator.getCurrentItem());
            iterator.next();
        }
        
    }