Alei最近和迭代器較上了勁，之前自以為深究過迭代器，不成想原來是坐井觀天，以蠡測海。上文中寫的東西哪裡算什麼深入探究？！但亡羊補牢，猶未遲也，經我多次試驗，終於弄懂其中某些精巧機制，閑話少說，我們進入正題。 註意，之後所有的知識點都以 ArrayList 這個容器類為例來進行詳細說明 在討論這個問 ...
Alei最近和迭代器較上了勁，之前自以為深究過迭代器，不成想原來是坐井觀天，以蠡測海。上文中寫的東西哪裡算什麼深入探究？！但亡羊補牢，猶未遲也，經我多次試驗，終於弄懂其中某些精巧機制，閑話少說，我們進入正題。
註意，之後所有的知識點都以 ArrayList 這個容器類為例來進行詳細說明
在討論這個問題之前我們得首先在意兩個成員變數：
1、ArrayList 類里繼承於 AbstractList 類的成員變數 modCount：
protected transient int modCount = 0;
2、ArrayList 類的私有內部類 Itr 里的成員變數 expectedModCount：
int expectedModCount = modCount;
再看下Itr類源碼：
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(); } } @Override @SuppressWarnings("unchecked") public void forEachRemaining(Consumer<? super E> 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 容器的 iterator() 方法後，在棧空間里創建了一個此類特定的迭代器對象，同時將成員變數 modCount 的值賦予成員變數 expectedModCount。知道這個有趣的事情後可以先打住，讓我們再來看看 ArrayList 類 remove() 方法的源碼：
參數為 int 類型的 remove()：
public E remove(int index) { rangeCheck(index); modCount++; E oldValue = elementData(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 oldValue; }
參數為 Object 類型的 remove()：
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 remove method that skips bounds checking and does not * return the value removed. */ private void fastRemove(int index) { modCount++; 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 }
以 ArrayList 類里 remove() 方法為例來看，只要我們調用此方法一次，那麼 modCount 便自加一次 1。於是我們可以理解，modCount 是一個記錄容器對象修改次數的變數，它是一個計數器。小伙伴門完全可以去查源碼，不僅僅是 remove()，凡是涉及對 ArrayList 對象的增、刪、改的任何一種方法，當我們調用一次這類方法，那 modCount 便會自加一次 1，即，記錄一次容器對象的改變。例如，當我創建一個 ArrayList 對象 al 後，我調用 al.add() 一次，調用 al.remove() 一次，再調用 al.add() 一次後，那麼 modCount = 3，由此說明 al 被修改了3次。
在沒有創建迭代器對象之前的任何對容器對象的增刪改操作只會讓 modCount 自加，當我們創建一個對應容器類的迭代器對象之後，int expectedModCount = modCount，迭代器對象里的 expectedModCount 成員變數被初始化為與 modCount 里的數值一樣的值。
有了迭代器，然後用迭代器進行迭代，就涉及到迭代器對象的 hasNext()；next()方法了，我們看下這兩個方法的源碼：
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]; }
由此可見，兩個方法都不會改變 expectedModCount 的值，那怎麼理解 expectedModCount 這個成員變數呢？再看迭代器里的 remove() 方法源碼：
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(); } }
在 remove() 方法的方法體里，有“expectedModCount = modCount; “這樣一行語句，那麼不管我們調用多少次迭代器的 remove() 方法，始終會讓 expectedModCount 的數值等於 modCount 的值，這裡的 expectedModCount 可理解為使用迭代器對容器類對象進行修改的”期望修改次數“，就是說：迭代器里的這個”期望修改次數“一定要和已經記錄下的容器的修改次數 modCount 一樣，那麼當你通過迭代器對容器類對象遍歷併進行修改時，使用迭代器本身的 remove() 才有意義（即讓 expectedModCount = modCount）！！而在 next() 方法體里首行的 checkForComodification() 方法是這樣定義的：
final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }
看了源碼，我們應該知道： checkForComodification() 的作用是檢查 expectedModCount 和 modCount 的值是否相等，如果不等，則拋出 ConcurrentModificationException 這個異常。這下顯而易見了，在我們通過迭代器進行遍歷時，若使用非迭代器對象提供的修改容器類對象的任何方法，則 modCount 的值增大，而 expectedModCount 地值不發生改變，那麼在進入下一次迴圈時，next() 方法體里首行的 checkForComodification() 方法檢查到 expectedModCount 與 modCount 不等後拋出了 ConcurrentModificationException。
那麼，在通過迭代器進行迭代時，容器對象里的任何元素都不能通過容器類所提供的方法進行增刪改的操作麽？非也非也，Alei留下這樣一段代碼：
public static void main(String[] args) { Collection c = new ArrayList(); c.add(new String("aaa")); c.add(new String("bbb")); c.add(new String("ccc")); c.add(new String("ddd")); c.add(new String("fff")); c.add(new String("eee")); for (Object o : c) { // System.out.print(o + " "); if (o.equals("fff")) { c.remove(o); } } System.out.println(c); }
當我們運行這段程式，你將會發現 ”fff“ 這個字元串對象怎麼被成功刪除了？！這也是我之前一直疑惑且略顯白痴的地方。其實，我可以下定結論：在通過迭代器進行迭代時，容器對象里的倒數第二個元素一定可以過容器類所提供的 remove() 方法進行刪除操作（不管這個容器的 size 有多大）。這又是為什麼呢？哈哈，對於這個問題，留待小伙伴們自行解決吧^_^！
