1.迭代器模式简介

所有的java程序员对Iterator都不陌生，只要是Collection，就都可以通过iterator()方法来获取迭代器Iterator，从而访问集合中的元素。迭代器模式(Iterator Pattern)是行为型(Behavioral)设计模式，为集合类提供了遍历集合元素的行为。

迭代器模式一共有四种角色：

(1) Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法。

(2) ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对集合对象的遍历。

(3) Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明了获取Iterator的抽象方法

(4) ConcreteAggregate（具体聚合类）： 实现了抽象聚合类中声明的获取Iterator的方法，返回具体迭代器。

2. 迭代器模式举例

下面我们模拟JDK源码中的一些类，来分析演示迭代器模式。

迭代器模式

1. MyIterator

我们首先来看MyIterator，它一般包括3个方法，分别是判断是否还有更多的元素、得到下一个元素、删除最后一个被遍历的元素。

public interface MyIterator<E> {

    // 是否还有更多的元素。
    boolean hasNext();
    
    // 得到下一个元素。
    E next();
    
    // 删除最后一个被遍历的元素，必须要在next()执行后才可以执行。
    void remove();

}

2. MyCollection

MyCollection接口中定义了获取迭代器的方法，另外，我们只选取了add和remove方法，用来解释迭代器设计模式足够了。

public interface MyCollection<E> {
    
    // 增加元素
    boolean add(E e);

    // 删除元素
    boolean remove(Object o);

    // 获取迭代器
    Iterator<E> iterator();
}

3. ArrayList 和 它的迭代器 Itr

public class MyArrayList<E> implements MyCollection {

    // 存储ArrayList 中的元素
    transient Object[] elementData;

    /**
     * 当前集合中元素的数目
     */
    private int size;

    /**
     * 为了演示方便，设置定长的数组
     */
    public MyArrayList() {
        this.elementData = new Object[1024];
    }

    /**
     * 把指定的对象添加到集合中。仅仅是演示，不考虑数组越界的情况。
     *
     * @param o 指定的对象
     * @return true，如果添加成功的话
     */
    @Override
    public boolean add(Object o) {
        elementData[size++] = o;
        return true;
    }

    /**
     * 如果对象在ArrayList中存在，就移除它。
     *
     * @param o 指定移除的对象
     * @return true，如果集合中包含指定的对象
     */
    @Override
    public boolean remove(Object o) {
        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) {
        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 MyIterator
     */
    @Override
    public MyIterator iterator() {
        return new Itr();
    }

    // ***** 内部类，迭代器 ***** //
    private class Itr implements MyIterator<E> {

        // 下一个元素的游标。
        int cursor;
        // 上一个返回的元素的index，-1代表没有这样的index。
        int lastRet = -1;


        /**
         * 判断集合 是否还有更多的元素
         *
         * @return true:有;false: 没有
         */
        @Override
        public boolean hasNext() {
            return cursor != size;
        }

        /**
         * 获取集合中的下一个元素
         *
         * @return E 下一个元素
         */
        @Override
        public E next() {
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = MyArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        /**
         * 移除上一个被访问的元素
         */
        @Override
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            try {
                MyArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    }
}

**4. 演示类 **

public class IteratorMain {

    public static void main(String[] args) {

        System.out.println("初始化MyArrayList");
        MyArrayList<Integer> arrayList = new MyArrayList<>();
        for (int i = 0; i < 10; i++) {
            arrayList.add(i);
        }
        System.out.println("移除一条数据");
        MyIterator<Integer> iterator = arrayList.iterator();
        if(iterator.hasNext()){
            Integer i = iterator.next();
            System.out.println(i);
            iterator.remove();
        }
        System.out.println("遍历集合中的数据");
        while (iterator.hasNext()){
            Integer i = iterator.next();
            System.out.println(i);
        }
    }
}

3. 总结

迭代器模式简化了集合的遍历方式，迭代器通常也是和集合类共生出现的；Java的中集合类中都提供了迭代器，实际的应用中使用到迭代器模式并不是很多。

4. 拓展

访问集合中的元素，有两种方法，一种是顺序访问，一种是随机访问；不同的集合类，可能使用不同的访问方式。以java.util.ArrayList为例，它可以通过public Iterator<E> iterator()方法获得迭代器，从而调用Iterator.next来顺序访问集合元素；同时，它还实现了java.util.RandomAccess接口，可以通过public E get(int index)方法来随机访问集合元素。

对于实现了随机访问的集合类，即实现了RandomAccess接口的类，比如ArrayList，使用fori循环，要比Iterator快。

// 对于实现RandomAccess的类，这样循环效率更高。
for (int i = 0; i < list.size(); i++)
    list.get(i);

// 对于实现RandomAccess的类，Iterator循环效率不如上面。
for (Iterator i=list.iterator(); i.hasNext(); )
    i.next();   

对于没有实现随机访问的集合类，例如LinkedList，fori循环速度要比for iterator要慢。
（完）