概念

根据网上的介绍，迭代子模式又叫游标(Cursor)模式，是对象的行为模式。迭代子模式可以顺序地访问一个聚集中的元素而不必暴露聚集的内部表象（internal representation）。
但按照我的理解，迭代子模式主要是针对 “一堆” 数据进行访问的一种模式，比如Collection接口和 Iterator接口。在Collection接口的具体实现类（如ArrayList）中实现了iterator（）方法用于返回一个Iterator接口的实现类的对象。而这个实现类主要提供了一系列的方法用于遍历操作的。

角色

抽象迭代子：定义出遍历元素所需的接口。
抽象聚集：提供生成具体迭代子的方法。
具体迭代子：实现抽象迭代子接口，并保存遍历过程中的游标位置。
具体聚集：继承抽象聚集，并返回一个适当的具体迭代子。

show you the code

抽象迭代子：

public interface Itertor {

    /**
     * 移动到第一个元素
     */
    public void first();
    
    /**
     * 迭代方法：移动到下一个元素
     */
    public void next();
    
    /**
     * 迭代方法：是否为最后一个元素
     */
    public boolean isDone();
    
    /**
     * 迭代方法：返还当前元素
     */
    public Object currentItem();

}

抽象聚集

/**
 * 抽象聚集
 *
 */
public abstract class AbsAggregate {
    
    /**
     * 暴露一个创造迭代器的方法
     */
    public abstract Itertor createItertor();
}

具体迭代子

public class ConcreteItertor implements Itertor{

    // 具体聚集器
    private ConcreteAggregater agg;
    
    //目前索引位置
    private int currentIndex;
    
    //聚集器大小
    private int aggreSize;
    
    public ConcreteItertor(ConcreteAggregater agg) {
        this.agg = agg;
        this.currentIndex = 0;
        this.aggreSize = agg.size();
    }

    @Override
    public void first() {
        currentIndex = 0;
    }

    @Override
    public void next() {
        if(currentIndex<aggreSize){
            currentIndex++;
        }
    }

    @Override
    public boolean isDone() {
        return currentIndex > aggreSize-1;
    }

    @Override
    public Object currentItem() {
        return agg.getElement(currentIndex);
    }

}

具体聚集

public class ConcreteAggregater extends AbsAggregate {

    private Object[] objectArray;
    
    public ConcreteAggregater(Object[] objArray) {
        this.objectArray = objArray;
    }
    
    @Override
    public Itertor createItertor() {
        return new ConcreteItertor(this);
    }
    
    public int size(){
        return objectArray.length;
    }

    /**
     * 提供获取尺寸的方法
     */
    public Object getElement(int index){
        if(index<size()){
            return objectArray[index];
        }else{
            return null;
        }
    }

}

测试类

public class Client {
    public static void main(String[] args) {
        Object[] objects = {"one","two","three","four","five"};
        AbsAggregate agg = new ConcreteAggregater(objects);
        Itertor it = agg.createItertor();
        while(!it.isDone()){
            System.out.println(it.currentItem());
            it.next();
        }
    }
}

结果

after that

其实迭代子模式有两种类型：一种叫外禀迭代子，一种叫内禀迭代子。故名思意，外禀迭代子就是我上面例子中讲的这种，是由一个外部类创建的迭代子，而内禀，当然是由我们的“具体聚集”的内部类创建的一个迭代子。
emm，在我看来，这两种的主要区别在于，外禀，是向所有的迭代子提供了访问具体对象的方法，而内禀，就是指定了某个迭代子才能访问，毕竟是内部类嘛。
这里贴一下内禀的代码。

public class ConcreteAggregate extends Aggregate {
    
    private Object[] objArray = null;
    /**
     * 构造方法，传入聚合对象的具体内容
     */
    public ConcreteAggregate(Object[] objArray){
        this.objArray = objArray;
    }
    
    @Override
    public Iterator createIterator() {
 
        return new ConcreteIterator();
    }
    /**
     * 内部成员类，具体迭代子类
     */
    private class ConcreteIterator implements Iterator
    {
        //内部索引，记录当前迭代到的索引位置
        private int index = 0;
        //记录当前聚集对象的大小
        private int size = 0;
        /**
         * 构造函数
         */
        public ConcreteIterator(){
            
            this.size = objArray.length;
            index = 0;
        }
        /**
         * 迭代方法：返还当前元素
         */
        @Override
        public Object currentItem() {
            return objArray[index];
        }
        /**
         * 迭代方法：移动到第一个元素
         */
        @Override
        public void first() {
            
            index = 0;
        }
        /**
         * 迭代方法：是否为最后一个元素
         */
        @Override
        public boolean isDone() {
            return (index >= size);
        }
        /**
         * 迭代方法：移动到下一个元素
         */
        @Override
        public void next() {
 
            if(index < size)
            {
                index ++;
            }
        }
    }
}

The end

按道理还是该说一下优缺点，优点嘛，很明显，迭代子来遍历，则聚集可以随意替换不同的迭代子，使用不同的遍历。
2：一个聚集可以同时用N个迭代子遍历。
缺点的话，以后领悟深刻了再补充。

迭代子模式