迭代器模式

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

迭代器抽象类：

package iterrator;

public abstract class Iterator {
    public abstract Object first();

    public abstract Object next();

    public abstract boolean isDone();

    public abstract Object currentItem();
}

聚合对象抽象类：

public abstract class Aggregate {
    public abstract Iterator createIterator();
}

具体迭代器类

public class ConcreteIterator extends Iterator{
    
    private ConcreteAggregate aggregate;
    private int current = 0;
    
    public ConcreteIterator(ConcreteAggregate aggregate){
        this.aggregate = aggregate;
    }
    
    @Override
    public Object first() {
        return aggregate.getItems().get(0);
    }

    @Override
    public Object next() {
        Object ret = null;
        current++;
        List<Object> items = aggregate.getItems();
        if(current < items.size()){
            ret = items.get(current);
        }
        return ret;
    }

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

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

具体聚合类：

public class ConcreteAggregate extends Aggregate{
    
    private List<Object> items = new ArrayList<Object>();

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
    
    public int count(){
        return items.size();
    }
    
    public Object getThis(int index){
        return items.get(index);
    }

    public List<Object> getItems() {
        return items;
    }

    public void setItems(List<Object> items) {
        this.items = items;
    }
    
}

客户端调用：

public class MainClass {
    public static void main(String[] args) {
        ConcreteAggregate a = new ConcreteAggregate();
        
        a.getItems().add("A");
        a.getItems().add("B");
        a.getItems().add("C");
        a.getItems().add("D");
        a.getItems().add("E");
        a.getItems().add("F");
        
        Iterator i = new ConcreteIterator(a);
        
        Object item = i.first();
        
        while(!i.isDone()){
            System.out.println(i.currentItem()+"请买票");
            i.next();
        }
        
    }
}

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