JAVA List 一边遍历一边删除元素,报java.util.ConcurrentModificationException异常

本文介绍了在Java中使用集合类如Set、Map和List时,常见的并发修改异常ConcurrentModificationException的问题及其解决方法。详细解释了错误场景,并提供了正确的代码示例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在使用set/map时,一个可爱的小bug:java.util.ConcurrentModificationException

 

【错误场景1】:set容器,边遍历,边add/remove元素

Set<String> set = new HashSet<String>();
for (int i = 0; i < 10000; i++) {
    set.add(Integer.toString(i));
}
for (String str : set) { //或使用iterator来循环,JDK5.0以上,这样的遍历底层也都是iterator实现。
    set.add("xxx"); //报错
//  set.remove(str); //报错
}
 
【错误场景2】:map容器,边遍历,边remove元素
Map<String, String> map = new HashMap<String, String>();
for (int i = 0; i < 100; i++) {
    map.put(Integer.toString(i), Integer.toString(i));
}
for (String str : map.keySet()) {//或使用iterator来循环
    map.remove(str); //报错
}
 
  
【错误场景3】list容器,边遍历,边add/remove元素
List<String> list = new ArrayList<String>();
        for (int i = 0; i < 100; i++) {
            list.add(Integer.toString(i));
        }
        for (Iterator<String> it = list.iterator(); it.hasNext();) { 
            String val = it.next();
            if (val.equals("5")) {
                list.add(val); //报错
                //     list.remove(val);   //报错    
            }
        }
 

【错误原因】

  • 对于remove操作,list.remove(o)的时候,只将modCount++,而expectedCount值未变,那么迭代器在取下一个元素的时候,发现该二值不等,则抛ConcurrentModificationException异常。
  • 对于add操作,同remove

【解决办法】

  • remove:用iterator提供的原生态remove()
  • add:同remove就错了,iterator没有提供原生的add()方法。真是的,还要用新的容器暂存,然后再遍历结束后,全部添加到原容器当中。

  • set/list:这两类常用容器,就用上面说的方法remove(), add()就好了。

  • map:直接使用ConcurrentHashMap就ok。为什么别的容器,不也实现个concurrent版本直接用。。?库里不搞,自己搞。

【正确使用案例】

for (Iterator<String> it = list.iterator(); it.hasNext();) {
    String val = it.next();
    if (val.equals("5")) {
        it.remove(); 
    }
}
List<String> newList = new ArrayList<String>(); 
for (Iterator<String> it = list.iterator(); it.hasNext();) {
    String val = it.next();
    if (val.equals("5")) {
        newList.add(val);
    }
}
list.addAll(newList);
 
   
 
  

转载自:http://www.cnblogs.com/alipayhutu/archive/2012/04/23/2465981.html


正确使用案例二:

public class Test {
	public static void main(String[] args) { 
        User user1 = new User();
        user1.setId(1);
        user1.setName("shangsan");

        User user2 = new User();
        user2.setId(2);
        user2.setName("lisi");

        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        
        System.out.println("userSet.size()  before--------------"+list.size());
        
        List<User> delList = new ArrayList<User>();
        for (Iterator<User> it = list.iterator(); it.hasNext();) { 
            User user = (User) it.next();
            if (user.getId() == 1) {
                delList.add(user);
            }
 
        }
        list.removeAll(delList);
        
        System.out.println("userSet.size()  after--------------"+list.size()); 
    }
}



### 解决方案 为了避免在遍历 `List` 集合时发生 `java.util.ConcurrentModificationException` 异常,可以采用以下几种方法: #### 使用迭代器的 remove 方法 当使用迭代器遍历列表并需要移除元素时,应该始终使用迭代器自己的 `remove()` 方法而不是集合本身的 `remove()` 或其他修改结构的方法。 ```java import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Example { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("A"); list.add("B"); list.add("C"); Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String element = iterator.next(); if ("B".equals(element)) { iterator.remove(); // 安全地移除元素 } } System.out.println(list); } } ``` 这种方法确保了即使在遍历过程中进行了删除操作也不会触发异常[^2]。 #### 利用并发安全的数据结构 对于多线程环境下的访问需求,可以选择使用线程安全版本的集合类来代替普通的 `ArrayList` 或者 `LinkedList`。例如 `CopyOnWriteArrayList` 可以有效防止此类问题的发生因为它会在每次写入前复制整个数组从而避免了结构性变化带来的影响。 ```java import java.util.concurrent.CopyOnWriteArrayList; // ...其余代码同上... List<String> threadSafeList = new CopyOnWriteArrayList<>(list); for (String item : threadSafeList){ if(someCondition(item)){ threadSafeList.remove(item); } } System.out.println(threadSafeList); ``` 这里需要注意的是虽然这种方式解决了异常的问题但它可能会带来性能上的开销因为每一次更新都需要拷贝全部数据[^5]。 #### 创建临时副本进行处理 另一种策略是在开始之前先创建原始列表的一个快照,在此基础上做任何必要的改动而不会干扰到正在被读取的那个实例。 ```java import java.util.Arrays; import java.util.List; // ...其余代码同上... List<String> originalList = Arrays.asList("A", "B", "C"); List<String> tempList = new ArrayList<>(originalList); tempList.forEach(e -> { if (!e.equals("B")) { // 对原列表的操作基于条件判断后的逻辑 originalList.removeIf(x->x.equals(e)); } }); System.out.println(originalList); ``` 这种做法能够很好地绕过因直接操纵源容器而导致的竞争状态[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值