源代码：https://gitee.com/AgentXiao/BehavioralPatterns
要点：
1、迭代器能干什么
2、迭代器的自定义实现

一、迭代器模式

提供一种可以遍历聚合对象的方式。又称为：游标cursor模式。

二、实现

要实现迭代器模式，首先需要提供聚合对象，用于储蓄数据；同时需要提供迭代器，用于遍历数据。

1、 聚合抽象类

/**
 * @interfaceName Aggregate
 * @Description 聚合抽象类
 * @Author xwd
 * @Date 2018/10/26 9:02
 */
public interface Aggregate  {
    /**
     * @MethodName addObj
     * @Descrition 添加元素
     * @Param [obj]
     * @return void
     */
    void addObj(Object obj);
    /**
     * @MethodName removeObj
     * @Descrition 移除元素
     * @Param [obj]
     * @return void
     */
    void removeObj(Object obj);
    /**
     * @MethodName getMyIterator
     * @Descrition 获得迭代器
     * @Param []
     * @return pri.xiaowd.iterator.MyIterator
     */
    MyIterator getMyIterator();
}

2、自定义的迭代器接口

/**
 * @interfaceName MyIterator
 * @Description 自定义的迭代器接口
 * @Author xwd
 * @Date 2018/10/26 9:05
 */
public interface MyIterator {
    /**
     * @MethodName first
     * @Descrition 将游标指向第一个元素
     * @Param []
     * @return void
     */
    void first();
    /**
     * @MethodName next
     * @Descrition 将游标指向下一个元素
     * @Param []
     * @return void
     */
    void next();
    /**
     * @MethodName hasNext
     * @Descrition 判断是否有下一个元素
     * @Param []
     * @return boolean
     */
    boolean hasNext();
    /**
     * @MethodName isFirst
     * @Descrition 判断是否是定义一个元素
     * @Param []
     * @return boolean
     */
    boolean isFirst();
    /**
     * @MethodName isLast
     * @Descrition 判断是否是最后一个元素
     * @Param []
     * @return boolean
     */
    boolean isLast();
    /**
     * @MethodName getCurrentObj
     * @Descrition 得到当前对象
     * @Param []
     * @return java.lang.Object
     */
    Object getCurrentObj();
}

3、具体聚合类（注意：一般使用内部类实现专属于该聚合类的迭代器）

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

/**
 * @ClassName ConcreteAggregate
 * @Description 具体聚合类
 * @Author xwd
 * @Date 2018/10/26 9:06
 */
public class ConcreteAggregate implements Aggregate{
    private List<Object> list = new ArrayList<>();

    @Override
    public void addObj(Object obj) {
        this.list.add(obj);
    }

    @Override
    public void removeObj(Object obj) {
        this.list.remove(obj);
    }

    @Override
    public MyIterator getMyIterator() {
        return new ConcreteIterator();
    }

    //一般使用内部类实现专属于该聚合类的迭代器
    public class ConcreteIterator implements MyIterator{

        private int cursor;//定义游标

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

        @Override
        public void next() {
            if(cursor < (list.size())){
                cursor++;
            }else{
                throw new RuntimeException("超出范围！");
            }
        }

        @Override
        public boolean hasNext() {
            if(cursor < (list.size())){
                return true;
            }
            return false;
        }

        @Override
        public boolean isFirst() {
            return cursor == 0 ? true : false;
        }

        @Override
        public boolean isLast() {
            return cursor == (list.size()-1) ? true : false;
        }

        @Override
        public Object getCurrentObj() {
            return list.get(cursor);
        }
    }
}

在这里需要特别注意的是hasNext()和next()两个方法的实现，进行游标比较时是小于(list.size())还是(list.size()-1)，通过推算我们可以知道，答案是前者。

4、测试

/**
 * @ClassName Client
 * @Description 测试
 * @Author xwd
 * @Date 2018/10/26 9:17
 */
public class Client {
    public static void main(String[] args) {
        //类似于List list = new ArrayList();
        Aggregate aggregate = new ConcreteAggregate();
        //类似于list.add("aaa");
        aggregate.addObj("aaa");
        aggregate.addObj("bbb");
        aggregate.addObj("ccc");
        //类似于list.remove("bbb");
        aggregate.removeObj("bbb");
        //获得迭代器并遍历聚合对象
        MyIterator myIterator = aggregate.getMyIterator();
        while (myIterator.hasNext()){
            System.out.println(myIterator.getCurrentObj());
            myIterator.next();
        }
    }
}

三、总结

1、开发中的场景

JDK内置的迭代器（List/Set）