[设计模式] 行为型：迭代器模式（Iterator Pattern）

什么是迭代器模式

首先声明一个观点，迭代器模式已经没落了，很少再有人单独写迭代器，除非是偏底层的产品性质的开发。

迭代器在各类应用框架中几乎都有涉及，现成的实现方案及应用都已经很完美了，没必要自己再去费心费力的造一个轮子。

迭代器是为容器服务的，容器就是可以存放许多对象的数据结构，遍历容器中每一个对象元素，就是迭代器最主要的事情。

JDK 1.2版本增加了java.util.Iterator接口，意味着 Java正式引入迭代器模式，并在此后，逐步将迭代器应用到各个容器类中。到今天为止，迭代器模式已经很好的融入到基本API中，使用非常轻松便捷。

迭代器的最大特点，无需关心容器结构及其内部元素的状态，只需按照迭代规则，即可将容器内所有元素遍历一遍。

除了最基本的遍历查询，还可以增强迭代器功能，对容器元素进行增删改等逻辑操作。不过话又说回来，运用迭代器进行增改操作没太大意义，删除操作倒还有些意义。因此，在Java里面，迭代器就只有遍历查询和删除元素的作用。

还有一点稍作注意，元素的遍历顺序是由迭代器内部定义的，和容器添加元素的顺序是两个概念。通常来讲，对于线性结构的容器，迭代器遍历顺序和容器添加顺序会保持一致。

设计与实现

对于Java开发者，了解迭代器的设计与实现，最好的方法就是去研读JDK集合类源码。

这里拿java.util.List举例，先来看看它的迭代器如何应用，然后再设计实现一个类似的迭代器。

List迭代器的使用代码，通常都是如此：

public static void main(String[] args) {
    // 准备容器，并添加对象元素
    List<String> list = new ArrayList<>();
    list.add("string1");
    list.add("string2");
    list.add("string3");

    // 使用迭代器遍历元素，找到 string2 并删除
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String str = iterator.next();
        if ("string2".equals(str)) iterator.remove();
    }
}

接下来仿照java.util.List实现一个自己的简化版容器MyList，并在内部实现一个自己的迭代器MyIterator：

// 迭代器接口定义
public interface MyIterator<T> {
    boolean hasNext();

    T next();

    void remove();
}

// 简化版容器定义，不可扩容，构造时需指定最大容量
public class MyArrayList<T> implements MyList<T> {
    private Object[] arr;
    int size = 0;

    public MyArrayList(int size) {
        arr = new Object[size];
    }

    @Override
    public T get(int i) {
        return (T) arr[i];
    }

    @Override
    public void add(T obj) {
        arr[size++] = obj;
    }

    @Override
    public void remove(T obj) {
        for (int i = 0; i < size; i++) {
            if (obj == arr[i]) {
                System.arraycopy(arr, i + 1, arr, i, size - i - 1);
                size--;
                break;
            }
        }
    }

    @Override
    public void remove(int index) {
        remove((T) arr[index]);
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public MyIterator<T> iterator() {
        return new MyListIterator<>();
    }

    // 内部实现的迭代器，具有遍历和删除功能
    private class MyListIterator<T> implements MyIterator<T> {
        private int index = -1;

        @Override
        public boolean hasNext() {
            return index + 1 != size;
        }

        @Override
        public T next() {
            T obj = null;
            if (this.hasNext()) obj = (T) arr[++index];
            return obj;
        }

        @Override
        public void remove() {
            MyArrayList.this.remove(index--);
        }
    }
}

简化版容器和内部的迭代器都已经实现好了，用法就跟Java API一样：

public static void main(String[] args) {
    // 准备容器，并添加对象元素，这里指定最大容量是3
    MyArrayList<String> list = new MyArrayList<>(3);
    list.add("string1");
    list.add("string2");
    list.add("string3");

    // 使用迭代器遍历元素，找到 string2 并删除
    MyIterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String str = iterator.next();
        if ("string2".equals(str)) iterator.remove();
    }
}

上述代码基本能表达出迭代器模式的设计思想和实现方法，代码未经过严格测试，可能会有bug。

再说得简单些，迭代器就是个封装在容器内部的游标指针，按照一定的规则指向容器内的元素，并且可对当前指向的元素进行一些操作。