Iterator分析

   写这篇论文的原因是因为我遇到一个java.util.ConcurrentModificationException

之前的代码片段如下：

 public void deleteProduct() {
        for (FavoriteFundModel module ：datas) {
            if ( module.isSelect() )
                datas.remove();
        }
        notifyDataSetChanged();
    }

当datas中的所有元素都被删除的时候就会出现 java.util.ConcurrentModificationException 错误。

先看Irerator的源码实现：

private class Itr implements Iterator<E> {  

    int cursor = 0;  

    int lastRet = -1;  

    int expectedModCount = modCount;  

    public boolean hasNext() {  

        return cursor != size();  

    }  

    public E next() {  

        checkForComodification();  

        try {  

            E next = get(cursor);  

            lastRet = cursor++;  

           return next;  

        } catch (IndexOutOfBoundsException e) {  

            checkForComodification();  

            throw new NoSuchElementException();  

        }  

    }  

    public void remove() {  

      if (lastRet == -1)  

            throw new IllegalStateException();  

        checkForComodification();  

        try {  

            AbstractList.this.remove(lastRet);  

            if (lastRet < cursor)  

                cursor--;  

            lastRet = -1;  

            // 修改expectedModCount 的值  

            expectedModCount = modCount;  

            } catch (IndexOutOfBoundsException e) {  

            throw new ConcurrentModificationException();  

        }  

    }  

    final void checkForComodification() {  

       if (modCount != expectedModCount)  

            throw new ConcurrentModificationException();  

    }  

  } 

modCount：The number of times this list has been structurally modified

expectedModCount：If this expectation is violated, the iterator has detected concurrent modification.and then throw exception

首先需要明确集合的修改操作(add/remove)中，都对modCount进行了+1，

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) {
        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
    }

         Iterator 是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表，

当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，

所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常

       所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象， Iterator.remove() 方法

会在删除当前迭代对象的同时维护索引的一致性。

　　有意思的是如果你的 Collection / Map 对象实际只有一个元素的时候， ConcurrentModificationException 异常并不会被抛出。

这也就是为什么在 javadoc 里面指出： it would be wrong to write a program that depended on this exception for its correctness: ConcurrentModificationException should be used only to detect bugs.