迭代器模式(Java)

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。

迭代器的思想是把聚合對象的遍历和访问从聚合对象中分离出来，放入单独的迭代器中，实现聚合对象和遍历的解耦。

(1)迭代器角色（Iterator）:定义遍历元素所需要的方法，一般来说会有这么三个方法：取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()），移出当前对象的方法remove(),

(2)具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。

(3)容器角色(Aggregate): 一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等

(4)具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。

这里就不单独举例子了，直接看list中的迭代器即可：

public interface Iterator {
    boolean hasNext();
    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
 }
 default void forEachRemaining(Consumer action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }

最后一个方法是java8之后提供的，跟函数式编程有关，可以使用lambda表达式遍历
再来看他的实现：

 /**
     * An optimized version of AbstractList.Itr
     */
    private class Itr implements Iterator {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

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

        @SuppressWarnings("unchecked")
        public E next() {
            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 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中元素，当然如果是我们自己设计的话，可能迭代器的实现是一个外部类，而其中会有一个ArrayList的对象。

通过这个迭代器，倒是看明白了ArrayList中如果遍历的时候remove的话可能有问题。比如：

        List list = new ArrayList<>();
        for(int i = 0; i <10 ;i++){
            list.add("test " + i);
        }

        for (int i = 0; i < list.size(); i++){
            if(i == 3){
                list.remove(i);
            }else{
                System.out.println(list.get(i));
            }
        }

输出的话，就会少输出 test 4 这个数据，为什么呢？ 因为ArrayList内部是数组存储，remove(3)之后，所有的数据在数组都会前移，所以原来放test 3的现在放了test 4，而i++ 之后，移到了下一个位置，所以就错过了。当然，如果这么遍历的话，就直接数组越界了：

        int size = list.size();
        for (int i = 0; i < size; i++){
            if(i == 3){
                list.remove(i);
            }else{
                System.out.println(list.get(i));
            }
        }

迭代器中实现的remove，位置还是当前的位置，所以不会出错。所以ArrayList中遍历的时候，要么使用迭代器删除，要么自己实现的时候，i不要++，比如：

       for (int i = 0; i < list.size();){
            if(i == 3){
                list.remove(i);
            }else{
                System.out.println(list.get(i));
                i++;
            }
        }

ArrayList中还实现了另外一个迭代器，ListIterator。 这个包含了向前遍历的方法：

    boolean hasPrevious();
    E previous();