Go语言视频零基础入门到精通

admin

在java语言中，ArrayList是一个很常用的类，在编程中经常要对ArrayList进行删除操作，在使用remove方法对ArrayList进行删除操作时，报java.util.ConcurrentModificationException异常，下面探讨一下该异常的原因以及解决办法。

1. 1 import java.util.ArrayList;
2. 2 import java.util.List;
3. 3
4. 4 public class Test {
5. 5
6. 6     public static void main(String[] args) {
7. 7         // TODO Auto-generated method stub
8. 8         List<Integer> listA=new ArrayList<>();
9. 9         listA.add(1);
10. 10         listA.add(2);
11. 11         listA.add(3);
12. 12         listA.add(4);
13. 13         listA.add(5);
14. 14         listA.add(6);
15. 15         
16. 16         for(Integer a:listA){
17. 17             if (a==3) {
18. 18                 listA.remove(3);
19. 19             }
20. 20         }
21. 21     }
22. 22 }

复制代码

上述代码在删除value=3的元素时，报java.util.ConcurrentModificationException异常，如下图

1. 1 Exception in thread "main" java.util.ConcurrentModificationException
2. 2     at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
3. 3     at java.util.ArrayList$Itr.next(ArrayList.java:851)
4. 4     at com.zhang.Test.main(Test.java:19)

复制代码

那么是不是删除每一个元素都会报上面的异常呢？经过测试发现，删除value=5的元素（倒数第二个元素）时，就不会报上面异常，除此之外均会报如上异常。（此处不再一一测试，有兴趣可自己编码测试）
我们通过上述测试发现了规律，既除了删除倒数第二个错误不会异常，删除其他元素均会异常。既然掌握了规律，那么就要从源码层面揭露该异常的原因。首先发现Java的for循环，就是将List对象遍历托管给Iterator，你如果要对list进行增删操作，都必须经过Iterator，否则Iterator遍历时会乱，所以直接对list进行删除时，Iterator会抛出ConcurrentModificationException异常。
其实，每次foreach迭代的时候都有两部操作：
第一步：iterator.hasNext()  //判断是否有下个元素

1.         public boolean hasNext() {
2.             return cursor != size;
3.         }

复制代码

第二步：item = iterator.next()  //下个元素是什么，并赋值给上面例子中的item变量

1. public E next() {
2.             checkForComodification();
3.             int i = cursor;
4.             if (i >= size)
5.                 throw new NoSuchElementException();
6.             Object[] elementData = ArrayList.this.elementData;
7.             if (i >= elementData.length)
8.                 throw new ConcurrentModificationException();
9.             cursor = i + 1;
10.             return (E) elementData[lastRet = i];
11.         }

复制代码

通过debug调试，我们发现，checkForComodification时返回了异常，异常原因为 modCount != expectedModCount。

1. final void checkForComodification() {
2.             if (modCount != expectedModCount)
3.                 throw new ConcurrentModificationException();
4.         }

复制代码

进一步阅读源码，发现：
　　1.modCount 时List从new开始，被修改的次数。当List调用Remove等方法时，modCount++
　　2.expectedModCount是指Iterator现在期望这个list被修改的次数是多少次。是在Iterator初始化的时候将modCount 的值赋给了expectedModCount
那么就解释了为什么会报上述异常：
　　1.modCount 会随着调用List.remove方法而自动增减，而expectedModCount则不会变化，就导致modCount != expectedModCount。
　　2.在删除倒数第二个元素后，cursor=size-1，此时size=size-1，导致hasNext方法认为遍历结束。

1. public class Test {
3.     public static void main(String[] args) {
4.         // TODO Auto-generated method stub
5.         List<Integer> listA=new ArrayList<>();
6.         listA.add(1);
7.         listA.add(2);
8.         listA.add(3);
9.         listA.add(4);
10.         listA.add(5);
11.         listA.add(6);
12.         
13.         for(Integer a:listA){
14.             System.out.println(a);
15.             if (a==5) {
16.                 listA.remove(5);
17.             }
18.         }
19.     }
20. }

复制代码

上述代码加了打印后，输出1,2,3,4,5;进一步证明最后一个元素6并没有被遍历到。
解决方法：
在找到原因后，则进一步进行解决
经过查阅源码可以发现，iterator也有一个remove方法如下，其中有一个重要的操作为expectedModCount = modCount;这样就保证了两者的相等。　

1. public void remove() {
2.             if (lastRet < 0)
3.                 throw new IllegalStateException();
4.             checkForComodification();
6.             try {
7.                 ArrayList.this.remove(lastRet);
8.                 cursor = lastRet;
9.                 lastRet = -1;
10.                 expectedModCount = modCount;
11.             } catch (IndexOutOfBoundsException ex) {
12.                 throw new ConcurrentModificationException();
13.             }
14.         }

复制代码

修改后的代码如下：

1. public class Test {
3.     public static void main(String[] args) {
4.         // TODO Auto-generated method stub
5.         List<Integer> listA=new ArrayList<>();
6.         listA.add(1);
7.         listA.add(2);
8.         listA.add(3);
9.         listA.add(4);
10.         listA.add(5);
11.         listA.add(6);
12.         Iterator<Integer> it_b=listA.iterator();
13.         while(it_b.hasNext()){
14.             Integer a=it_b.next();
15.             if (a==4) {
16.                 it_b.remove();
17.             }
18.         }
19.         for(Integer b:listA){
20.             System.out.println(b);
21.         }
22.     }
23. }

复制代码

  
java.util.ConcurrentModificationException异常完美解决。