如何解決Java中ArrayList在foreach里remove的問題

這篇文章給大家分享的是有關如何解決Java中ArrayList在foreach里remove的問題的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

前言

ArrayList就是傳說中的動態數組，用MSDN中的說法，就是Array的復雜版本，它提供了如下一些好處：

• 動態的增加和減少元素

• 實現了ICollection和IList接口

• 靈活的設置數組的大小

都說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()之后的代碼比較簡單這里就不分析了。

倒數第二個元素的特殊

到這里我們來捋一捋大致的流程：

獲取到Itr對象賦值給var2

判斷hasNext，也就是判斷cursor != size，當前迭代元素下標不等于list的個數，則返回true繼續迭代；反之退出循環

next取出迭代元素

• checkForComodification() ，判斷modCount != expectedModCount，元素數量變更次數不等于初始化內部類Itr的時元素變更次數，也就是在迭代期間做過修改就拋ConcurrentModificationException。

• 如果檢查通過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()校驗，但是看到后面又重新賦值了，所以又相等了。

感謝各位的閱讀！關于“如何解決Java中ArrayList在foreach里remove的問題”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！