關於list刪除元素的當時有很多，具體可以參考下面這個部落格。

https://blog.csdn.net/claram/article/details/53410175

裡面提到了list的foreach遍歷方式刪除元素，會丟擲ConcurrentModificationException。foreach是迭代器遍歷的一種簡寫。
但是，如果list中只有兩個元素，刪除第一個元素時，則不會丟擲ConcurrentModificationException異常。

首先看一下迭代器的hasNext()和next()方法原始碼。

        public boolean hasNext() {
        // 當前元素的位置不等於list的size代表還有元素沒有遍歷
 

            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
        //檢查是否有迭代器之外的modify
            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];
        }
        final void checkForComodification() {
        //expectedModCount 是迭代器自己維護的變數
        //modCount 是list中元素修改的數量
 

        //如果呼叫迭代器的方法對list操作，二者是相等的。例如下面的remove方法
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                //保證expectedModCount和modCount相等
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

在看一下ArrayList的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 void fastRemove(int index) {
    //移除元素，modcount++
        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只有兩個元素，刪除第一個元素的程式碼如下：

    public static void main(String []args) {
        List<String> list = new ArrayList<>();
        list.add("ddd");
        list.add("aaa");
        for (String string : list) {
            if (string.equals("aaa")) {
                list.remove(string);
            }
            System.out.println(string);
        }
    }

上面程式碼並沒有丟擲任何異常，關鍵在於迭代器遍歷第一個元素後，此時cursor=1，modCount=expectedModCount=2，size=2；
刪除第一個元素後，cursor=1，modCount=3，expectedModCount=2，size=1；
繼續執行迭代器的hasNext()時，發現cursor==size==1，迭代器認為已經遍歷結束。並沒有繼續執行next函式，還沒有來得及執行checkForComodification()迴圈已經結束。

總結
在這種特殊情況下，雖然此時並沒有丟擲異常，但是也沒有按照我們的預想，將兩個元素全部遍歷完，只遍歷了一個元素就結束了，在刪除元素時，還應當使用迭代器更加安全。