迭代器模式

迭代器模式（iterator）

迭代器模式是对象的行为模式。迭代器模式可以顺序低访问一个聚集中的元素而不必暴露聚集的内部表象。

1、结构

• 聚合对象：存储数据
• 迭代器：遍历数据

角色：

• 抽象迭代子（Iterator）角色：定义遍历元素所需的接口
• 具体迭代子（ConcreteIterator）角色：实现了Iterator接口，并保持迭代过程中的游标位置
• 聚集（Agregate）角色：给出创建迭代子（Iterator）对象接口
• 具体聚集（ConcreteAggregate）角色：实现了创建迭代子（Iterator）对象的接口

2、迭代器模式demo

uml：

(1)、自定义迭代器接口，定义变量元素的各种方法

/**
 * Created by xh.zhi on 2018-10-31.
 * 自定义的迭代器接口
 * 抽象迭代子（Iterator）角色：定义遍历元素所需的接口
 */
public interface MyIterator {
    /**是否第一个**/
    boolean isFirst();

    /**是否最后一个**/
    boolean isLast();

    /**第一个**/
    Object first();

    /**最后一个**/
    Object last();

    /**游标下一个**/
    boolean hasNext();

    /**读取当前对象**/
    Object getCurrentObj();


}

（2）、自定义聚集接口，定义创建迭代器的方法，以及一些操作数据的简单方法

/**
 * Created by xh.zhi on 2018-10-31.
 *  聚集（Agregate）角色：给出创建迭代子（Iterator）对象接口
 */
public interface MyAggregate {
    /**
     * 创建迭代子
     * @return
     */
    MyIterator  createIterator();

    /**
     * 添加一个元素
     * @param obj
     */
    void addObject(Object obj);


    /**
     * 删除一个元素
     * @param obj
     */
    void removeObject(Object obj);


}

（3）因为迭代器遍历是需要用到聚合类存储的数据，所以迭代器的实现类作为具体聚集类的内部类。

/**
 * Created by xh.zhi on 2018-10-31.
 *  具体聚集（ConcreteAggregate）角色：实现了创建迭代子（Iterator）对象的接口
 */
public class ConcreteMyAggregate implements MyAggregate {
    //存储数据
    private List<Object> list = new ArrayList<Object>();

    /**
     * 添加一个元素
     * @param obj
     */
    @Override
    public void addObject(Object obj){
        list.add(obj);
    }

    /**
     * 删除一个元素
     * @param obj
     */
    @Override
    public void removeObject(Object obj){
        list.remove(obj);
    }


    /**
     * 创建迭代器
     * @return
     */
    @Override
    public MyIterator createIterator() {
        return new ConcreteIterator() ;
    }

    /**
     * Created by xh.zhi on 2018-10-31.
     * 定义迭代器。 内部类，比较容易使用聚集类的集合对象
     *  具体迭代子（ConcreteIterator）角色：实现了Iterator接口，并保持迭代过程中的游标位置
     */
    private class ConcreteIterator implements MyIterator{
        //定义游标用于记录遍历时的位置
        private int cursor;

        @Override
        public boolean isFirst() {
            return cursor==0;
        }

        @Override
        public boolean isLast() {
            return cursor == list.size();
        }

        @Override
        public Object first() {
            return list.get(0);
        }

        @Override
        public Object last() {
            int lastIndex = list.size()-1;
            return  list.get(lastIndex);
        }

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

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

（4）测试

public static void main(String[] args) {
    //创建聚集实例
    MyAggregate collection = new ConcreteMyAggregate();
    //添加元素
    collection.addObject("olay");
    collection.addObject("james");
    collection.addObject("kobi");
    collection.addObject("cp3");
    collection.addObject("test");

    //删除元素
    collection.removeObject("test");

    //获取迭代器
    MyIterator iterator = collection.createIterator();

    System.out.println("first obj = "+iterator.first());
    System.out.println("last obj = "+iterator.last());

    System.out.println("遍历集合：");
    //迭代器遍历聚集
    while (iterator.hasNext()){
        String value = iterator.getCurrentObj().toString();
        System.out.println(value);
    }
}

first obj = olay
last obj = cp3
遍历集合：
olay
james
kobi
cp3

3、开发中常见的场景：

• JDK内置的迭代器(List/Set)