我們這篇部落格來介紹一下迭代器模式（Iterator Pattern），又稱為遊標（Cursor Pattern）模式，是行為型設計模式之一。迭代器模式算是一個比較古老的設計模式，其源於對容器的訪問，比如 Java 中的 List、Map、陣列等，我們知道對容器物件的訪問必然會涉及遍歷演算法，我們可以將遍歷的方法封裝在容器中，或者不提供遍歷方法。如果我們將遍歷的方法封裝到容器中，那麼對於容器類來說就承擔了過多的功能，容器類不僅要維護自身內部的資料元素而且還要對外提供遍歷的介面方法，因為遍歷狀態的儲存問題還不能對同一個容器同時進行多個遍歷操作，如果我們不提供遍歷方法而讓使用者自己去實現，又會讓容器的內部細節暴露無遺，正因於此，迭代模式應運而生，在客戶訪問類與容器體之間插入一個第三者——迭代器，很好地解決了上面所述的弊端。
　　轉載請註明出處：

設計模式總目錄

特點

　　提供一種方法順序訪問一個聚合物件中的各個元素，而又不暴露其內部的表示。
　　迭代器模式讓我們能遊走於聚合內的每一個元素，而又不暴露其內部的表示，把遊走的任務放在迭代器上，而不是聚合上。這樣簡化了聚合的介面和實現，也讓責任各得其所。
　　迭代器模式使用的場景也很簡單：遍歷一個容器物件時。

UML類圖

　　
迭代器模式角色：

• Iterator：迭代器介面
迭代器介面負責定義、訪問和遍歷元素的介面。
• ConcreteIterator：具體迭代器類
具體迭代器類的目的主要是實現迭代器介面，並記錄遍歷的當前位置。
• Aggregate：容器介面
容器介面負責提供建立具體迭代器角色的介面。
• ConcreteAggregate：具體容器類
具體迭代器角色與該容器相關聯。
• Client：客戶類

public interface Iterator<T> {
    boolean hasNext();

    T next();
}

ConcreteIterator.class

public class ConcreteIterator<T
 
> implements Iterator<T>{
    private List<T> list;
    private int cursor = 0;

    public ConcreteIterator(List<T> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return cursor != list.size();
    }

    @Override
    public T next() {
        T obj = null;
        if (this.hasNext()) {
            obj = this.list.get(cursor++);
        }
        return obj;
    }
}

容器類：
Aggregation.class

public interface Aggregation<T> {

    void add(T obj);

    void remove(T obj);

    Iterator<T> iterator();
}

ConcreteAggregation.class

public class ConcreteAggregation<T> implements Aggregation<T>{
    private List<T> list = new ArrayList<>();

    @Override
    public void add(T obj) {
        list.add(obj);
    }

    @Override
    public void remove(T obj) {
        list.remove(obj);
    }

    @Override
    public Iterator<T> iterator() {
        return new ConcreteIterator<>(list);
    }
}

客戶端程式碼

public class Client {
    public static void main(String args[]) {
        Aggregation<String> a = new ConcreteAggregation<>();
        a.add("a");
        a.add("b");
        a.add("c");
        Iterator<String> iterator = a.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next());
        }
    }
}

最後結果就是遍歷了一遍：

abc
Process finished with exit code 0

示例與原始碼

　　迭代器這個模式對於很多開發者來說幾乎不會自己去實現一個迭代器，但是我們平時使用的頻率不會低，在 Android 中，除了各種資料結構體，如 List、Map 等所包含的迭代器外，資料庫查詢的 Cursor 也是一個迭代器。
　　我們這裡就簡單分析一下 ArrayList 的 Iterator 原始碼：
Iterator.class

public interface Iterator<E> {
    /**
     * Returns {@code true} if the iteration has more elements.
     * (In other words, returns {@code true} if {@link #next} would
     * return an element rather than throwing an exception.)
     *
     * @return {@code true} if the iteration has more elements
     */
    boolean hasNext();

    /**
     * Returns the next element in the iteration.
     *
     * @return the next element in the iteration
     * @throws NoSuchElementException if the iteration has no more elements
     */
    E next();

    /**
     * Removes from the underlying collection the last element returned
     * by this iterator (optional operation).  This method can be called
     * only once per call to {@link #next}.  The behavior of an iterator
     * is unspecified if the underlying collection is modified while the
     * iteration is in progress in any way other than by calling this
     * method.
     *
     * @throws UnsupportedOperationException if the {@code remove}
     *         operation is not supported by this iterator
     *
     * @throws IllegalStateException if the {@code next} method has not
     *         yet been called, or the {@code remove} method has already
     *         been called after the last call to the {@code next}
     *         method
     */
    void remove();
}

ArrayList.Itr.class

private class Itr implements Iterator<E> {
    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();
        }
    }

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

這就是 ArrayList 迭代器的具體實現，從原始碼中我們可以看到有一個 checkForComodification() 函式，丟擲的異常 ConcurrentModificationException 應該很多人認識，如果 modCount 不等於 expectedModCount，則丟擲 ConcurrentModificationException 異常，一般情況下出現在遍歷的同時呼叫了 ArrayList.remove 等操作對資料集合進行了更改，例如多執行緒中當一個執行緒刪除了元素，由於 modCount 是 AbstarctList 的成員變數，因此可能會導致在其他執行緒中modCount 和 expectedModCount 值不等。

總結

　　對於迭代模式來說，其自身優點很明顯：

• 迭代子模式簡化了聚集的介面，迭代子具備了一個遍歷介面，這樣聚集的介面就不必具備遍歷介面；
• 每一個聚集物件都可以有一個或多個迭代子物件，每一個迭代子的迭代狀態可以是彼此獨立的。因此，一個聚集物件可以同時有幾個迭代在進行之中；
• 由於遍歷演算法被封裝在迭代子角色裡面，因此迭代的演算法可以獨立於聚集角色變化。

原始碼下載

引用