list set集合remove() ConcurrentModificationException 原因

方法一、

        ArrayList<String> list = new ArrayList<String>();         
 list.add("one");         
 list.add("two");         
 list.add("two");        
 list.add("two");         
 list.add("two");                 
 for(int i=0;i<list.size();i++){                         
  if(list.get(i).equals("two")){                         
   list.remove(i);                 
  }        
 }        
  System.out.println(list);


执行结果

[one, two, two]

注意: 此种方法可以删除list的数据,但删除后list的数据会自动向前面移动,这样会导致执行的结果和想要达到的效果不一样。


方法二、

        ArrayList<String> list2 = new ArrayList<String>();         
  list2.add("one");         
  list2.add("two");         
  list2.add("two");         
  list2.add("two");         
  list2.add("two");         
  for(String s:list2){             
   if(s.equals("two")){              
    list2.remove(s);             
   }         
  }         
  System.out.println(list2);

执行结果

Exception in thread "main" java.util.ConcurrentModificationException  at java.util.AbstractList$Itr.checkForComodification(AbstractList.java:372)  at java.util.AbstractList$Itr.next(AbstractList.java:343)  at com.learn.jdk16.util.ConcurrentModification.main(ConcurrentModification.java:40)


方法三、

         ArrayList<String> list3 = new ArrayList<String>();         
  list3.add("one");         
  list3.add("two");         
  list3.add("two");         
  list3.add("two");         
  list3.add("two");         
  Iterator<String> iter = list3.iterator();         
  while(iter.hasNext()){             
  String s = iter.next();            
   if(s.equals("two")){                 
    iter.remove();             
   }         
  }         
  System.out.println(list3);

执行结果

[one]

删除还是用迭代器的比较好,其它的都会有问题.
----------------------------------------------------------

 对ArrayList的操作我们可以通过索引象来访问,也可以通过Iterator来访问,只要不对ArrayList结构上进行修改都不会造成ConcurrentModificationException,单独用索引对ArrayList进行修改也不会造成该问题,造成该问题主要是在索引和Iterator混用。可以通过JDK的源码来说明该问题。

   首先看下AbstractList的Iterator内的代码:

 

  1. /** 
  2. *在Iterator的内部有个expectedModCount 变量, 
  3. *该变量每次初始化*Iterator的时候等于ArrayList的modCount,modCount记录了对ArrayList的结构修改次数, 
  4. *在通过Iterator对ArrayList进行结构的修改的时候都会将expectedModCount 与modCount同步, 
  5. *但是如果在通过Iterator访问的时候同时又通过索引的方式去修改ArrayList的结构的话, 
  6. *由于通过索引的方式只会修改modCount不会同步修改expectedModCount 就会导致 
  7. *modCount和expectedModCount 不相等就会抛ConcurrentModificationException, 
  8. *这也就是Iterator的fail-fast,快速失效的。所以只要采取一种方式操作ArrayList就不会出问题, 
  9. *当然ArrayList不是线程安全的,此处不讨论对线程问题。 
  10. * 
  11. */  
  12. int expectedModCount = modCount;  
  13. public E next() {  
  14.             checkForComodification();//判断modeCount与expectedModCount 是否相等,如果不相等就抛异常  
  15.         try {  
  16.         E next = get(cursor);  
  17.         lastRet = cursor++;  
  18.         return next;  
  19.         } catch (IndexOutOfBoundsException e) {  
  20.         checkForComodification();  
  21.         throw new NoSuchElementException();  
  22.         }  
  23. }  
  24.   
  25. public void remove() {  
  26.      if (lastRet == -1)  
  27.         throw new IllegalStateException();  
  28.           checkForComodification();//同样去判断modeCount与expectedModCount 是否相等  
  29.   
  30.       try {  
  31.         AbstractList.this.remove(lastRet);  
  32.         if (lastRet < cursor)  
  33.             cursor--;  
  34.         lastRet = -1;  
  35.         expectedModCount = modCount;//此处修改ArrayList的结构,所以要将expectedModCount 于modCount同步,主要是AbstractList.this.remove(lastRet);的remove方法中将modCount++了,导致了modCount与expectedModCount 不相等了。  
  36.        } catch (IndexOutOfBoundsException e) {  
  37.         throw new ConcurrentModificationException();  
  38.        }  
  39. }  
  40.   
  41. //判断modCount 与expectedModCount是否相等,如果不相等就抛ConcurrentModificationException异常  
  42. final void checkForComodification() {  
  43.      if (modCount != expectedModCount)  
  44.           throw new ConcurrentModificationException();  
  45. }  
 

故结论是:对ArrayList的操作采用一种遍历方式,要么索引,要么Iterator别混用即可。

下面是网上看见别人的解释:写道

Iterator 是工作在一个独立的线程中,并且拥有一个 mutex 锁。 Iterator 被创建之后会建立一个指向原来对象的单链索引表,当原来的对象数量发生变化时,这个索引表的内容不会同步改变,所以当索引指针往后移动的时候就找不到要迭代的对象,所以按照 fail-fast 原则 Iterator 会马上抛出 java.util.ConcurrentModificationException 异常。
所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象, Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
本系统的研发具有重大的意义,在安全性方面,用户使用浏览器访问网站时,采用注册和密码等相关的保护措施,提高系统的可靠性,维护用户的个人信息和财产的安全。在方便性方面,促进了校园失物招领网站的信息化建设,极大的方便了相关的工作人员对校园失物招领网站信息进行管理。 本系统主要通过使用Java语言编码设计系统功能,MySQL数据库管理数据,AJAX技术设计简洁的、友好的网址页面,然后在IDEA开发平台中,编写相关的Java代码文件,接着通过连接语言完成与数据库的搭建工作,再通过平台提供的Tomcat插件完成信息的交互,最后在浏览器中打开系统网址便可使用本系统。本系统的使用角色可以被分为用户和管理员,用户具有注册、查看信息、留言信息等功能,管理员具有修改用户信息,发布寻物启事等功能。 管理员可以选择任一浏览器打开网址,输入信息无误后,以管理员的身份行使相关的管理权限。管理员可以通过选择失物招领管理,管理相关的失物招领信息记录,比如进行查看失物招领信息标题,修改失物招领信息来源等操作。管理员可以通过选择公告管理,管理相关的公告信息记录,比如进行查看公告详情,删除错误的公告信息,发布公告等操作。管理员可以通过选择公告类型管理,管理相关的公告类型信息,比如查看所有公告类型,删除无用公告类型,修改公告类型,添加公告类型等操作。寻物启事管理页面,此页面提供给管理员的功能有:新增寻物启事,修改寻物启事,删除寻物启事。物品类型管理页面,此页面提供给管理员的功能有:新增物品类型,修改物品类型,删除物品类型。
`java.util.ConcurrentModificationException` 是Java中的一个异常,通常在使用迭代器(Iterator)对集合(如ListSet、Map)进行遍历时出现。它表示在遍历过程中,集合的内容发生了修改,导致迭代器检测到了并抛出异常。 这个异常通常有以下几个可能的原因: 1. 直接在遍历过程中对集合进行了增删操作:在使用迭代器遍历集合时,如果直接对集合进行增删操作(如调用`add()`、`remove()`等方法),导致迭代器的内部状态与集合的状态不一致,从而触发`ConcurrentModificationException`异常。 2. 多线程并发修改同一个集合:如果多个线程同时对同一个集合进行修改操作,就可能引发`ConcurrentModificationException`异常。因为多线程并发修改同一个集合时,无法保证迭代器的一致性。 3. 使用了不正确的迭代方式:在某些情况下,使用迭代器遍历集合的方式可能导致`ConcurrentModificationException`异常。比如,在使用增强型for循环(foreach)遍历集合时,如果在循环内部对集合进行了增删操作,就可能出现异常。 解决这个异常的常见方法是使用`Iterator`的安全删除方法`remove()`来进行元素的删除操作,或者使用并发安全的集合类(如`ConcurrentHashMap`、`CopyOnWriteArrayList`)来替代普通的集合类。此外,还可以使用`synchronized`关键字或`Lock`机制来对集合的操作进行同步,以避免并发修改问题

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值