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介面中的三個方法。