迭代器模式提供一种顺序访问某个集合中所有元素的解决方案，而不用了解集合底层的操作。

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

当需要访问一个聚合对象，并且不管这些对象是什么都要遍历一遍的时候，就应该考虑使用迭代器模式。
迭代器应该为不同的聚集结构提供如开始，下一位，是否遍历到聚集尾部，当前位于聚集中哪一个位置等的统一接口。

下面上代码

package Iterator;public abstract class Aggregate {    public abstract Iterator CreateIterator();
}

package Iterator;import java.util.ArrayList;import java.util.List;public class ConcreteAggregate extends Aggregate{    private List<Object> items = new ArrayList<Object>();    public int getSize()
    {        return items.size();
    }    
    public Object getItem(int i)
    {        return items.get(i);
    }    
    public void setItem(int i,Object obj)
    {
        items.add(i,obj);
    }    @Override
    public Iterator CreateIterator() {        // TODO Auto-generated method stub
        return new ConcreteIterator(this);
    }
}

package Iterator;public abstract class Iterator {    public abstract Object First();    public abstract Object Next();    public abstract Boolean IsDone();    public abstract Object CurrentItem();
}

package Iterator;public class ConcreteIterator extends Iterator{    private ConcreteAggregate aggregate;    private int current = 0;    public ConcreteIterator(ConcreteAggregate aggregate)
    {        this.aggregate = aggregate;
    }    @Override
    public Object First() {        // TODO Auto-generated method stub
        return this.aggregate.getItem(0);
    }    @Override
    public Object Next() {        // TODO Auto-generated method stub
        Object obj = null;
        current++;        if(current < this.aggregate.getSize())
        {
            obj = this.aggregate.getItem(current);
        }        return obj;
    }    @Override
    public Boolean IsDone() {        // TODO Auto-generated method stub
        if(current >= this.aggregate.getSize())
        {            return true;
        }        else 
        {            return false;
        }
    }    @Override
    public Object CurrentItem() {        // TODO Auto-generated method stub
        return this.aggregate.getItem(current);
    }
}

package Iterator;public class client {    public static void main(String[] args)
    {
        ConcreteAggregate ca = new ConcreteAggregate();        for(int i = 0;i<10;i++)
        {
            ca.setItem(i, "求职者"+(i+1));
        }
        Iterator it = new ConcreteIterator(ca);        while(!it.IsDone())
        {
            System.out.println(it.CurrentItem() + "请来我公司面试！");
            it.Next();
        }
    }
}

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

迭代器适用于以下几种情况：

1. 当需要访问一个聚合对象的内容而又不想暴露他的内部表示的时候

2. 当希望支持对聚集对象的多种遍历方式时

3. 当需要为遍历不同的聚集结构提供统一的对外接口时

作者：球球球球笨
链接：https://www.jianshu.com/p/87971ede89c7