1 引言

在实际应用中，我们尝尝需要访问一个聚合对象中的全部元素，而不需要关心元素的内部情况。例如，公交车售票员售票，不管上车的是男士女士，老人小孩儿，只要上车就需要买票。这对应于迭代器模式。

2 定义

迭代器（Iterator）模式：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

3 结构与实现

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。

迭代器模式主要包含以下角色：

抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

结构图如下图所示（图片来自引用2）：

4 优缺点

4.1 优点

访问一个聚合对象的内容而无须暴露它的内部表示。
遍历任务交由迭代器完成，这简化了聚合类。
它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
增加新的聚合类和迭代器类都很方便，无须修改原有代码。
封装性良好，为遍历不同的聚合结构提供一个统一的接口。

4.2 缺点

增加了类的个数，这在一定程度上增加了系统的复杂性。

5 应用场景

当需要为聚合对象提供多种遍历方式时。
当需要为遍历不同的聚合结构提供一个统一的接口时。
当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

6 代码讲解

在Java中，Collection、List、Set、Map 等都包含了迭代器。接下来看看Java中List的迭代器实现。

6.1 迭代器接口 Iterator

public interface Iterator<E> {
    //获取下一个元素，第一次调用给出第一项，第二次给出第二项，。。。
     E next();
     //是否存在下一个，存在true，不存在false
     boolean hasNext();
     //从底层集合中删除迭代器返回的最后一个元素，就是next()返回的集合中的元素
     default void remove() {
        throw new UnsupportedOperationException("remove");
     }
     //对每个剩余的元素进行一定的操作，Consumer是函数式接口
     default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }

}

接口中的default函数是Java8新引入特性，default修饰方法只能在接口中使用，在接口中被default标记的方法为普通方法，可以直接写方法体。

6.2 ArrayList中的Iterator实现

获取Iterator实例

public Iterator<E> iterator() {
        return new Itr();
    }

私有类Itr

private class Itr implements Iterator<E> {
        //下一个元素返回的索引
        int cursor;
        //最后一个元素的索引，没有为-1，获取实例Iterator时，为-1
        int lastRet = -1;
        // expectedModCount 预期集合元素被修改次数 modCount 集合被修改的数量
        int expectedModCount = modCount;

        Itr() {}

        /**
         * 判断元素
         * @return 是否还有元素
         */
        public boolean hasNext() {
            return cursor != size;
        }

        //返回下一个元素
        @SuppressWarnings("unchecked")
        public E next() {
            // 关键一步，调用checkForComodification（）会去校验expectedModCount 和modCount是否相等，不等抛异常
            //集合元素被修改一次，modCount自加一次
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                //修改 让预期修改次数与实际修改次数相等
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public void forEachRemaining(Consumer<? super E> consumer) {
            Objects.requireNonNull(consumer);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i >= size) {
                return;
            }
            final Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
            while (i != size && modCount == expectedModCount) {
                consumer.accept((E) elementData[i++]);
            }
            // update once at end of iteration to reduce heap write traffic
            cursor = i;
            lastRet = i - 1;
            checkForComodification();
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

ArrayList.this.remove(lastRet)

 public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        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

        return oldValue;
    }

6.3 主函数测试

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i + 1);
        }
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
            iterator.remove();
        }
    }