迭代器模式

类图

代码

interface Iterator{
    Object next();
    boolean hasNext();
}

interface Aggregate{
    void add(Object obj);
    Iterator iterator();
}

ConcreteAggregate & ConcreteIterator

class MyArray implements Aggregate{

    private int cursor;

    private Object[] elements;

    private int size;

    public MyArray() {
        cursor = 0;
        size = 1;
        elements = new Object[size];
    }

    @Override
    public void add(Object obj) {
        if(this.elements.length >= size){
            expand();
        }
        this.elements[cursor++] = obj;
    }

    private void expand(){
        Object[] newElements = new Object[size * 2];
        System.arraycopy(elements, 0, newElements, 0, size);
        elements = newElements;
        size = size * 2;
    }

    @Override
    public Iterator iterator() {
        return new MyArrayIterator();
    }

    private class MyArrayIterator implements Iterator{

        private int current;

        public MyArrayIterator() {
            this.current = 0;
        }

        @Override
        public Object next() {
            return MyArray.this.elements[current++];
        }

        @Override
        public boolean hasNext() {
            return current < MyArray.this.cursor;
        }
    }
}

总结

概述

文中的例子实现了一个java中ArrayList的简略版

迭代器模式往往与集合成对出现

它很好的实现了数据结构和算法的解耦

比如文中在使用MyArray集合的时候，你并不需要关心里面的存储结构是怎样的

优点

符合设计原则中的单一职责原则

弱化了容器类和遍历算法之间的关系

缺点

为了遍历会曾加不少代码量

遍历单向切不可逆

会出现ConcurrentModificationException异常(迭代过程中元素发生了变化)