Java ArrayList在foreach中remove的問題分析

目錄

• iterator
• itr.hasNext 和 itr.next 實現
• 倒數第二個元素的特殊
• 如何避坑

都說ArrayList在用foreach循環的時候，不能add元素，也不能remove元素，可能會拋異常，那咱們就來分析一下它具體的實現。我目前的環境是Java8。

有下面一段代碼：

public class TestForEachList extends BaseTests {

    @Test
    public void testForeach() {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");

        for (String s : list) {
        }
    }

}

代碼很簡單，一個ArrayList添加3個元素，foreach循環一下，啥都不幹。那麼foreach究竟是怎麼實現的呢，暴力的方法看一下，編譯改類，用 javap -c TestForEachList查看class文件的字節碼，以下：

javap -c TestForEachList 
Warning: Binary file TestForEachList contains collection.list.TestForEachList
Compiled from "TestForEachList.java"
public class collection.list.TestForEachList extends com.ferret.BaseTests {
  public collection.list.TestForEachList();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method com/ferret/BaseTests."<init>":()V
       4: return

  public void testForeach();
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: ldc           #4                  // String 1
      11: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      16: pop
      17: aload_1
      18: ldc           #6                  // String 2
      20: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      25: pop
      26: aload_1
      27: ldc           #7                  // String 3
      29: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      34: pop
      35: aload_1
      36: invokeinterface #8,  1            // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;
      41: astore_2
      42: aload_2
      43: invokeinterface #9,  1            // InterfaceMethod java/util/Iterator.hasNext:()Z
      48: ifeq          64
      51: aload_2
      52: invokeinterface #10,  1           // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
      57: checkcast     #11                 // class java/lang/String
      60: astore_3
      61: goto          42
      64: return
}

能夠勉強讀，大約是調用了List.iterator，而後根據iterator的hasNext方法返回結果判斷是否有下一個，根據next方法取到下一個元素。

可是是總歸是體驗很差，咱們是現代人，因此用一些現代化的手段，直接用idea打開該class文件自動反編譯，獲得以下內容：

public class TestForEachList extends BaseTests {
    public TestForEachList() {
    }

    @Test
    public void testForeach() {
        List<String> list = new ArrayList();
        list.add("1");
        list.add("2");
        list.add("3");

        String var3;
        for(Iterator var2 = list.iterator(); var2.hasNext(); var3 = (String)var2.next()) {
            ;
        }

    }
}

體驗好多了，再對比上面的字節碼文件，沒錯

for(Iterator var2 = list.iterator(); var2.hasNext(); var3 = (String)var2.next()) {
            ;
        }

這就是脫掉語法糖外殼的foreach的真正實現。

接下來咱們看看這三個方法具體都是怎麼實現的：

iterator

ArrayList的iterator實現以下：

public Iterator<E> iterator() {
    return new 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;
    //省略部分實現
}

Itr是ArrayList中的內部類，因此list.iterator()的做用是返回了一個Itr對象賦值到var2，後面調用var2.hasNext()，var2.next()就是Itr的具體實現了。

這裏還值的一提的是expectedModCount， 這個變量記錄被賦值爲modCount， modCount是ArrayList的父類AbstractList的一個字段，這個字段的含義是list結構發生變動的次數，一般是add或remove等致使元素數量變動的會觸發modCount++。

下面接着看itr.hasNext()``var2.next()的實現。

itr.hasNext 和 itr.next 實現

hasNext很簡單

public boolean hasNext() {
            return cursor != size;
        }

當前index不等於size則說明還沒迭代完，這裏的size是外部類ArrayList的字段，表示元素個數。

在看next實現：

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

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

next方法第一步 checkForComodification()，它作了什麼？ 若是modCount != expectedModCount就拋出異常ConcurrentModificationException。modCount是什麼？外部類ArrayList的元素數量變動次數；expectedModCount是什麼？初始化內部類Itr的時候外部類的元素數量變動次數。

因此，若是在foreach中作了add或者remove操做會致使程序異常ConcurrentModificationException。這裏能夠走兩個例子：

@Test(expected = ConcurrentModificationException.class)
    public void testListForeachRemoveThrow() {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");

        for (String s : list) {
            list.remove(s);
        }
    }

    @Test(expected = ConcurrentModificationException.class)
    public void testListForeachAddThrow() {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");

        for (String s : list) {
            list.add(s);
        }
    }

單元測試跑過，都拋了ConcurrentModificationException。

checkForComodification()以後的代碼比較簡單這裏就不分析了。

倒數第二個元素的特殊

到這裏咱們來捋一捋大體的流程：

1. 獲取到Itr對象賦值給var2
2. 判斷hasNext，也就是判斷cursor != size，當前迭代元素下標不等於list的個數，則返回true繼續迭代；反之退出循環
3. next取出迭代元素
   1. checkForComodification()，判斷modCount != expectedModCount，元素數量變動次數不等於初始化內部類Itr的時元素變動次數，也就是在迭代期間作過修改就拋ConcurrentModificationException。
   2. 若是檢查經過cursor++

下面考慮一種狀況：remove了倒數第二個元素會發生什麼？代碼以下：

@Test
public void testListForeachRemoveBack2NotThrow() {
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");

    for (String s : list) {
        System.out.println(s);
        if ("2".equals(s)) {
            list.remove(s);
        }
    }
}

猜一下會拋出異常嗎？答案是否認的。輸出爲：

1
2

發現少了3沒有輸出。 分析一下

在倒數第二個元素"2"remove後，list的size-1變爲了2，而此時itr中的cur在next方法中取出元素"2"後，作了加1，值變爲2了，致使下次判斷hasNext時，cursor==size，hasNext返回false，最終最後一個元素沒有被輸出。

如何避坑

foreach中remove 或 add 有坑，

• 在foreach中作致使元素個數發生變化的操做(remove, add等)時，會拋出ConcurrentModificationException異常
• 在foreach中remove倒數第二個元素時，會致使最後一個元素不被遍歷

那麼咱們如何避免呢？不能用foreach咱們就用fori嘛，以下代碼：

@Test
    public void testListForiMiss() {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
            list.remove(i);
        }
    }

很明顯上面是一個錯誤的示範，輸出以下：

1
3

緣由很簡單，原來的元素1被remove後，後面的向前拷貝，2到了原來1的位置（下標0），3到了原來2的位置（下標1），size由3變2，i+1=1，輸出list.get(1)就成了3，2被漏掉了。

下面說下正確的示範：

方法一，仍是fori，位置前挪了減回去就好了, remove後i--：

@Test
    public void testListForiRight() {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
            list.remove(i);
            i--;  //位置前挪了減回去就好了
        }
    }

方法二，不用ArrayList的remove方法，用Itr本身定義的remove方法，代碼以下：

@Test
    public void testIteratorRemove() {
        List<String> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");

        Iterator<String> itr = list.iterator();
        while (itr.hasNext()) {
            String s = itr.next();
            System.out.println(s);
            itr.remove();
        }
    }

爲何itr本身定義的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();
            }
        }

依然有 checkForComodification()校驗，可是看到後面又從新賦值了，因此又相等了。

ok，以上就是所有內容。介紹了foreach中list remove的坑，以及如何避免。