Java集合迭代器 Iterator分析

Iterator是个接口，是对 collection 进行迭代的迭代器，用来遍历collection元素。但为什么Iterator要定义成一个接口，而非一个类呢？另外，Iterator又是如何实现对collection的遍历的呢？在对此分析之前，先看下Iterator的用法。

Iterator用法

Iterator中有三个方法：
boolean hasNext()
E next()
void remove()
遍历collection时，先调用Collection子类中的iterator()方法创建迭代器对象，并用hasNext()方法判断，如果仍有元素可迭代，再调用next()方法，返回迭代的下一个元素，依次循环直到最后一个元素。如下：

public class IteratorTest {
    public static void main(String[] args) {
//      创建ArrayList<String>对象
        ArrayList<String> arrList = new ArrayList<>();

//      添加元素
        arrList.add("Iterator");
        arrList.add("迭代器");
        arrList.add("遍历");

//      用Iterator遍历
        Iterator<String> itr = arrList.iterator();

        while(itr.hasNext()){
            System.out.println(itr.next());
        }

/*  或者用for循环
for(Iterator<String> itr1 = arrList.iterator();itr1.hasNext();){
        System.out.println(itr1.next());
} */        
    }

}

Iterator原理分析

接口作用在于扩展功能，其中的方法只有特征，没有实现。在Eclipse查看Iterator的源码可知，Iterator也是如此。如下：

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

进一步查看源码可知，Collection子类ArrayList中实现了Iterator接口中的三个方法。如下：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final Object[] EMPTY_ELEMENTDATA = {};
    private transient Object[] elementData;
    private int size;// ArrayList中元素的个数

    // 常见的构造方法，由这里可知，ArrayList的底层是数组
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    // ArrayList类中的iterator（）方法，
    //返回的是一个实现了Iterator接口的具体类的对象
    public Iterator<E> iterator() {
            return new Itr();
    }

    // Itr实现了Iterator接口，并且是ArrayList的内部类
    private class Itr implements Iterator<E> {
        //游标：要返回元素的索引
        int cursor;     
        // 上一个返回元素的索引，如果上次没有返回，为-1  
        int lastRet = -1; 
        int expectedModCount = modCount;

    /**
     * hasNext()方法：判斷游标是否等于底层数组长度。
     * 等于说明遍历已到达数组最后，无元素可供遍历；
     * 否则继续遍历。
     */
        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中的remove（int index）方法
                ArrayList.this.remove(lastRet);
                //游标改为上次返回元素的索引
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }   
    }   
}

由上面的源码可知，Iterator中的方法在ArrayList中的实现依赖于ArrayList底层的数据结构。同样地，这三个方法在Collection其他子类中的实现也都依赖于子类不同的结构，所以具体的实现也不完全相同。这也是Iterator为什么要定义成一个接口的原因。（Collection子类底层的结构不一样，对不同的collection遍历，采用的方式也就不一样，所以每个collection都有自己独特的遍历方式。因此Iterator就不可能对各自不同的遍历作出统一的实现，而是让collection本身实现元素的遍历。这样Iterator就不能定义为类了，而只能是接口。）

总结

每个collection都实现了自己独特的元素遍历方式，这种实现依赖于各自的结构。使用Iterator遍历，遍历器对象来自于collection子类自身的iterator( )方法，而遍历器对象对应的类中实现了Iterator接口中的三个方法。