ArrayList在循環過程中刪除中出現的問題

前言

之前搜索面試題的時候，出現了一個題：一個ArrayList在循環過程中刪除，會不會出問題，為什么？心里想的答案是肯定會有問題但是又不知道是為什么，在搜索到答案后，發現里面其實並不簡單，所以專門寫篇文章研究一下。

for循環正向刪除

先看示例，再解析原因：

public static void main(String[] args){
        List<String> list = new ArrayList<String>();

        list.add("111");
        list.add("222");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("333");
        //for循環正向循環刪除
        for (int i = 0;i < list.size();i++){
            if (list.get(i).equals("222")){
                list.remove(i);
            }
        }
        System.out.println(Arrays.toString(list.toArray()));
    }

運行后，輸出結果：

[111, 222, 333, 444, 333]

發現，相鄰的字符串“222”沒有刪除，這是為什么呢？畫圖解釋：

解釋：刪除元素“222”，當循環到下標為1的元素的的時候，發現此位置上的元素是“222”，此處元素應該刪除，根據上圖中的元素移動可知，在刪除元素后面的所有元素都要向前移動一個位置，那么移動之后，原來下標為2的元素“222”，此時下標為1，這是在i = 1,時的循環操作，在下一次的循環中，i = 2，此時就遺漏了第二個元素“222”。

那么再做下一個測試，刪除元素“333”，結果將如何？

public static void main(String[] args){
        List<String> list = new ArrayList<String>();

        list.add("111");
        list.add("222");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("333");
        //for循環正向循環刪除
        for (int i = 0;i < list.size();i++){
            if (list.get(i).equals("333")){
                list.remove(i);
            }
        }
        System.out.println(Arrays.toString(list.toArray()));
    }

運行結果：

[111, 222, 222, 444]

發現，沒有問題。原理在上一個測試已經說了，就不再贅述。

總結：for循環正向刪除，會遺漏連續重復的元素。

 for循環反向刪除

public static void main(String[] args){
        List<String> list = new ArrayList<String>();

        list.add("111");
        list.add("222");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("333");
        //for循環反向循環刪除
        for (int i = list.size() - 1;i >= 0;i--){
            if (list.get(i).equals("222")){
                list.remove(i);
            }
        }
        System.out.println(Arrays.toString(list.toArray()));
    }

運行結果：

[111, 333, 444, 333]

 發現，沒有問題。還是畫圖解釋：

反向刪除的時候，循環遍歷完了的元素下標才有可能移動（已經遍歷的元素，下標變化了也沒有影響），所以沒有遍歷的下標不會移動，自反向刪除會遍歷到所有的元素，正向會跳過一些元素。

總結：反向遍歷刪除，沒有問題（單線程）。

反向遍歷刪除（多線程）

public static void main(String[] args) {
                ArrayList<String> list = new ArrayList<String>();
                list.add("111");
                list.add("222");
                list.add("222");
                list.add("333");
                list.add("444");
                list.add("333");

                Thread thread1 = new Thread() {
                    @Override
                    public void run() {
                        remove(list,"111");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                Thread thread2 = new Thread() {
                    @Override
                    public void run() {
                        remove(list, "222");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                Thread thread3 = new Thread() {
                    @Override
                    public void run() {
                        remove(list, "333");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                // 使各個線程處於就緒狀態
                thread1.start();
                thread2.start();
                thread3.start();
                // 等待前面幾個線程完成
                try {
                    thread1.join();
                    thread2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Arrays.toString(list.toArray()));
            }

            public static void remove(ArrayList<String> list, String elem) {
                // 普通for循環倒序刪除，刪除過程中元素向左移動，不影響連續刪除
                for (int i = list.size() - 1; i >= 0; i--) {
                    if (list.get(i).equals(elem)) {
                        list.remove(list.get(i));
                    }
                }
            }

運行結果：

[444]

總結：多線程反向遍歷刪除，沒有問題。

Iterator循環刪除

public static void main(String[] args){
        List<String> list = new ArrayList<String>();

        list.add("111");
        list.add("222");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("333");
        //foreach循環刪除
        Iterator iterator = list.iterator();
       while (iterator.hasNext()){
           if (iterator.next().equals("222")){
               list.remove(iterator.next());
           }
       }
        System.out.println(Arrays.toString(list.toArray()));
    }

運行結果：

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
    at java.util.ArrayList$Itr.next(ArrayList.java:859)
    at joe.effective.Test.main(Test.java:20)

 這個問題就要借助源碼來分析了（JDK1.8）：

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;
}

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
}

可以看出，ArrayList的remove方法，一種是根據下標刪除，一種是根據元素刪除。

發現即使看了remove方法的源碼也不能找到報錯的原因，由於我們使用了Iterator迭代器，那么再看看迭代器的源碼，果不其然，就發現了問題所在：

private class Itr implements Iterator<E>
private class ListItr extends Itr implements ListIterator<E> 

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();
}

Itr和ListItr是ArrayList的兩個私有內部類，Itr實現了Iterator接口，ListItr繼承了Itr類和實現了ListIterator接口。Itr類中也有一個remove方法，迭代器實際調用的也正是這個remove方法，上述源碼也就是這個方法的源碼。

由源碼的第二段代碼可以看出，這個remove方法中調用了ArrayList中的remove方法，在這個方法中我們注意到了expectedModCount變量和modCount變量，modCount在前面的代碼中也見到了，它記錄了ArrayList修改的次數，而前面的變量expectedModCount，這個變量的初值和modCount是相等的；同時在ArrayList.this.remove(lastRet)；代碼面前，調用了檢查次數的方法checkForComodification()，這個方法做的事情很簡單，就是如果expectedModCount和modCount不相等，那么就拋出異常ConcurrentModificationException。

我們在用Iterator循環刪除的時候，調用的是ArrayList里面的remove方法，刪除元素后modCount會增加，expectedModCount則不變，這樣就造成了expectedModCount ！= modCount，那么就拋出異常了。

再用Iterator中的remove方法來測試：

public static void main(String[] args){
        List<String> list = new ArrayList<String>();

        list.add("111");
        list.add("222");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("333");
        
        Iterator iterator = list.iterator();
       while (iterator.hasNext()){
           if (iterator.next().equals("222")){
               iterator.remove();
           }
       }
        System.out.println(Arrays.toString(list.toArray()));
    }

運行結果：

[111, 333, 444, 333]

發現，刪除成功且沒有報錯。

什么原因呢？我們調用的了Iterator中的迭代器刪除元素，在這個方法中有：expectedModCount = modCount這樣一句代碼，所以當我們每刪除一次元素，就同步一次，所以調用checkForComodification()時，就不會報錯。如果換到多線程中，這個方法不能保證兩個變量修改的一致性，結果具有不確定性，所以不推薦這種方法。

總結：Iterator調用ArrayList的刪除方法報錯，Iterator調用迭代器自己的刪除方法，單線程不會報錯，多線程會報錯。

forEach循環刪除

public static void main(String[] args){
        List<String> list = new ArrayList<String>();

        list.add("111");
        list.add("222");
        list.add("222");
        list.add("333");
        list.add("444");
        list.add("333");
        //foreach循環刪除
        for (String str : list){
            if (str.equals("222")){
                list.remove(str);
            }
        }

        System.out.println(Arrays.toString(list.toArray()));
    }

運行結果：

Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
    at java.util.ArrayList$Itr.next(ArrayList.java:859)
    at joe.effective.Test.main(Test.java:20)

報錯。

foreach原理是因為這些集合類都實現了Iterable接口，該接口中定義了Iterator迭代器的產生方法，並且foreach就是通過Iterable接口在序列中進行移動。也就是說：在編譯的時候編譯器會自動將對for這個關鍵字的使用轉化為對目標的迭代器的使用

明白了原理就跟上述的Iterator刪除調用ArrayList中remove一樣了。

總結：forEach循環刪除報錯。