正文

在JDK中已经为我们提供了大量实现了迭代器的容器类。
因此我们可以不用关心，诸如：Linkedlist与ArrayList之间的差别，却仍能保障我们完成工作。

现在我们需要思索，JDK是怎么做到这一切的？现在让我们先利用迭代器实现一个数组类型Array，这个类型需要支持添加、移除、遍历操作。

实现

STEP 1

定义迭代器接口，实现该接口的类拥有迭代器职责。这叫好像在20年前，家门口停了一辆小汽车，别人都会知道你是万元户一样。

public interface Iterable<T> {
    Iterator<T> iterator();
}

STEP 2

定义迭代器对象，除却基本的hasNext、next方法。额外定义了add、remove方法，这会辅助我们操作集合中的元素。

注意：迭代器不仅仅为了{迭代}，而是为了{操作}集合中的元素。

public interface Iterator<E> {
    boolean hasNext();

    E next();

    boolean add(E e);

    boolean addAll(Collection<? extends E> e);

    boolean remove(E e);
}

STEP 3

实现一个数组Array模拟数组的操作，所有访问集合中元素的操作全权委托给iterator对象。Array并不关心操作元素的细节，它只向外暴露操作接口，对收到的请求转发给iterator处理。

public class Array<E> implements Iterable<E> {

    private transient Iterator<E> iterator;

    public Array() {
        this.iterator = iterator();
    }

    public Array(Collection<? extends E> collection) {
        this.iterator = iterator();
        this.iterator.addAll(collection);
    }

    @Override
    public Iterator<E> iterator() {
        synchronized (this) {
            if (iterator == null) {
                iterator = new ArrayIteratorImpl<>();
            }
        }
        return iterator;
    }

    public void add(E e) {
        this.iterator.add(e);
    }

    public void addAll(Collection<? extends E> e) {
        this.iterator.addAll(e);
    }

    public void remove(E e) {
        this.iterator.remove(e);
    }

}

STEP 4

定义迭代器实现类，使用接口抽象迭代器是为了满足开闭原则，这样Array可以随时更换迭代器而不会影响现有的接口。

ArrayIteratorImpl迭代器实现了对数组的添加、移除操作，如何分配元素、选择用什么容器存储、遍历的顺序、甚至是否启用并行操作，这些对于Array都是不可感知的。

public class ArrayIteratorImpl<E> implements Iterator<E> {

    private transient Object[] elementData = {};
    private transient static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    private static final int DEFAULT_CAPACITY = 10;
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    protected transient int modCount = 0;
    private int size;

    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

    @Override
    public boolean hasNext() {
        return cursor != size;
    }

    @Override
    public E next() {
        int i = cursor;
        if (i >= size)
            throw new IllegalArgumentException("");
        Object[] elementData = this.elementData;
        if (i >= elementData.length)
            throw new IllegalArgumentException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    @Override
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        lastRet = -1;
        return true;
    }

    @Override
    public boolean addAll(Collection<? extends E> e) {
        final Object[] a = e.toArray();
        final int numNew = e.size();
        ensureCapacityInternal(this.size + numNew);
        System.arraycopy(a, 0, elementData, size, numNew);
        this.size += numNew;
        lastRet = -1;
        return numNew != 0;
    }

    @Override
    public boolean remove(E o) {
        lastRet = -1;
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index + 1, elementData, index,
                    numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

}

STEP 5

客户端调用测试

public class Client {

    public static void main(String[] args) {
        Array<String> array = new Array();
        array.add("清华大学");
        array.add("北京大学");
        array.add("浙江大学");
        array.add("武汉大学");
        array.add("西安交通大学");
        array.add("上海交通大学");
        array.add("人民大学");


        Iterator<String> iterator = array.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            System.out.println(item);
        }
    }
}

总结

迭代器模式属于行为模式类别。

迭代器本质：控制访问集合中的元素

迭代器模式.png