在迭代和从ArrayList中删除元素时,如何避免java.util.ConcurrentModificationException

时间:2011-11-12 13:22:40

标签: java arraylist foreach

我有一个我想迭代的ArrayList。迭代它时,我必须同时删除元素。显然这会引发java.util.ConcurrentModificationException

处理此问题的最佳做法是什么?我应该首先克隆列表吗?

我删除了不在循环本身的元素,而是代码的另一部分。

我的代码如下所示:

public class Test() {
    private ArrayList<A> abc = new ArrayList<A>();

    public void doStuff() {
        for (A a : abc) 
        a.doSomething();
    }

    public void removeA(A a) {
        abc.remove(a);
    }
}

a.doSomething可能会调用Test.removeA();

21 个答案:

答案 0 :(得分:264)

两个选项:

  • 在循环中创建要删除的值列表添加到该列表,然后在结尾处调用originalList.removeAll(valuesToRemove)
  • 在迭代器本身上使用remove()方法。请注意,这意味着您无法使用增强型for循环。

作为第二个选项的示例,从列表中删除长度大于5的任何字符串:

List<String> list = new ArrayList<String>();
...
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
    String value = iterator.next();
    if (value.length() > 5) {
        iterator.remove();
    }
}

答案 1 :(得分:16)

来自ArrayList的JavaDocs

  

此类的迭代器和listIterator返回的迭代器   方法是快速失败的:如果列表在结构上被修改了   创建迭代器后的时间,以任何方式除外   迭代器自己删除或添加方法,迭代器会抛出一个   ConcurrentModificationException的。

答案 2 :(得分:8)

你应该以传统方式迭代数组

每次从列表中删除元素时,后面的元素都将向前推进。只要您不更改迭代后的元素,以下代码就可以工作。

public class Test(){
    private ArrayList<A> abc = new ArrayList<A>();

    public void doStuff(){
        for(int i = (abc.size() - 1); i >= 0; i--) 
            abc.get(i).doSomething();
    }

    public void removeA(A a){
        abc.remove(a);
    }
}

答案 3 :(得分:7)

在Java 8中,您可以使用Collection Interface并通过调用removeIf方法执行此操作:

yourList.removeIf((A a) -> a.value == 2);

可以找到更多信息here

答案 4 :(得分:6)

以正常方式执行循环,java.util.ConcurrentModificationException是与所访问元素相关的错误。

所以试试:

for(int i = 0; i < list.size(); i++){
    lista.get(i).action();
}

答案 5 :(得分:5)

一种选择是将removeA方法修改为此 -

public void removeA(A a,Iterator<A> iterator) {
     iterator.remove(a);
     }

但这意味着您的doSomething()应该能够将iterator传递给remove方法。不是一个好主意。

你能用两步法做到这一点:  在迭代列表时的第一个循环中,标记作为要删除的 ,而不是删除所选元素。为此,您可以简单地将这些元素(浅拷贝)复制到另一个List

然后,一旦你的迭代完成,只需从第一个列表中的removeAll执行第二个列表中的所有元素。

答案 6 :(得分:5)

下面是一个示例,我使用不同的列表添加要删除的对象,然后我使用stream.foreach从原始列表中删除元素:

private ObservableList<CustomerTableEntry> customersTableViewItems = FXCollections.observableArrayList();
...
private void removeOutdatedRowsElementsFromCustomerView()
{
    ObjectProperty<TimeStamp> currentTimestamp = new SimpleObjectProperty<>(TimeStamp.getCurrentTime());
    long diff;
    long diffSeconds;
    List<Object> objectsToRemove = new ArrayList<>();
    for(CustomerTableEntry item: customersTableViewItems) {
        diff = currentTimestamp.getValue().getTime() - item.timestamp.getValue().getTime();
        diffSeconds = diff / 1000 % 60;
        if(diffSeconds > 10) {
            // Element has been idle for too long, meaning no communication, hence remove it
            System.out.printf("- Idle element [%s] - will be removed\n", item.getUserName());
            objectsToRemove.add(item);
        }
    }
    objectsToRemove.stream().forEach(o -> customersTableViewItems.remove(o));
}

答案 7 :(得分:4)

在迭代列表时,如果要删除元素是可能的。让我们看看下面的例子,

ArrayList<String>  names = new ArrayList<String>();
        names.add("abc");
        names.add("def");
        names.add("ghi");
        names.add("xyz");

我有上面的数组列表名称。我想从上面的列表中删除“def”名称,

for(String name : names){
    if(name.equals("def")){
        names.remove("def");
    }
}

上面的代码抛出 ConcurrentModificationException 异常,因为您在迭代时修改了列表。

因此,要通过这种方式从Arraylist中删除“def”名称,

Iterator<String> itr = names.iterator();            
while(itr.hasNext()){
    String name = itr.next();
    if(name.equals("def")){
        itr.remove();
    }
}

上面的代码,通过迭代器我们可以从Arraylist中删除“def”名称并尝试打印数组,你会看到下面的输出。

输出:[abc,ghi,xyz]

答案 8 :(得分:3)

不使用For each循环,而是使用normal for循环。例如,下面的代码删除了数组列表中的所有元素,而没有给出java.util.ConcurrentModificationException。您可以根据用例修改循环中的条件。

   for(int i=0;i<abc.size();i++)  {

          e.remove(i);
        }

答案 9 :(得分:2)

这样简单:

for (Object object: (ArrayList<String>) list.clone()) {
    list.remove(object);
}

答案 10 :(得分:1)

使用stream的替代Java 8解决方案:

        theList = theList.stream()
            .filter(element -> !shouldBeRemoved(element))
            .collect(Collectors.toList());

在Java 7中,您可以使用Guava:

        theList = FluentIterable.from(theList)
            .filter(new Predicate<String>() {
                @Override
                public boolean apply(String element) {
                    return !shouldBeRemoved(element);
                }
            })
            .toImmutableList();

请注意,Guava示例会生成一个不可变列表,可能是您想要的也可能不是。

答案 11 :(得分:1)

for (A a : new ArrayList<>(abc)) {
    a.doSomething();
    abc.remove(a);
}

答案 12 :(得分:0)

“我应该首先克隆列表吗?”

这将是最简单的解决方案,从克隆中删除,并在删除后复制克隆。

我的朗姆酒游戏中的一个例子:

SuppressWarnings("unchecked")
public void removeStones() {
  ArrayList<Stone> clone = (ArrayList<Stone>) stones.clone();
  // remove the stones moved to the table
  for (Stone stone : stones) {
      if (stone.isOnTable()) {
         clone.remove(stone);
      }
  }
  stones = (ArrayList<Stone>) clone.clone();
  sortStones();
}

答案 13 :(得分:0)

如果您的目标是从列表中删除所有元素,则可以遍历每个项目,然后调用:

list.clear()

答案 14 :(得分:0)

我知道迟到了,但我回答了这个问题,因为我认为此解决方案简单而优雅:

List<String> listFixed = new ArrayList<String>();
List<String> dynamicList = new ArrayList<String>();

public void fillingList() {
    listFixed.add("Andrea");
    listFixed.add("Susana");
    listFixed.add("Oscar");
    listFixed.add("Valeria");
    listFixed.add("Kathy");
    listFixed.add("Laura");
    listFixed.add("Ana");
    listFixed.add("Becker");
    listFixed.add("Abraham");
    dynamicList.addAll(listFixed);
}

public void updatingListFixed() {
    for (String newList : dynamicList) {
        if (!listFixed.contains(newList)) {
            listFixed.add(newList);
        }
    }

    //this is for add elements if you want eraser also 

    String removeRegister="";
    for (String fixedList : listFixed) {
        if (!dynamicList.contains(fixedList)) {
            removeResgister = fixedList;
        }
    }
    fixedList.remove(removeRegister);
}

所有这些都是为了从一个列表更新到另一个列表,而您可以仅从一个列表中进行所有更新 在方法更新中,您同时检查列表和可以在列表之间擦除或添加元素。 这意味着两个列表始终具有相同的大小

答案 15 :(得分:0)

使用迭代器代替数组列表

已将集合转换为类型为match的迭代器

然后移至下一个元素并删除

Iterator<Insured> itr = insuredSet.iterator();
while (itr.hasNext()) { 
    itr.next();
    itr.remove();
}

在这里移至下一个很重要,因为它应该使用索引来删除元素。

答案 16 :(得分:0)

您还可以使用CopyOnWriteArrayList代替ArrayList。这是JDK 1.5以后推荐的最新方法。

答案 17 :(得分:0)

对于我来说,接受的答案不起作用,它会停止Exception,但会导致List中的某些不一致。以下解决方案非常适合我。

List<String> list = new ArrayList<>();
List<String> itemsToRemove = new ArrayList<>();

for (String value: list) {
   if (value.length() > 5) { // your condition
       itemsToRemove.add(value);
   }
}
list.removeAll(itemsToRemove);

在此代码中,我在另一个列表中添加了要删除的项目,然后使用list.removeAll方法删除了所有必需的项目。

答案 18 :(得分:0)

关于

import java.util.Collections;

List<A> abc = Collections.synchronizedList(new ArrayList<>());

答案 19 :(得分:0)

错误

将元素添加到同一列表中时出现错误:

fun <T> MutableList<T>.mathList(_fun: (T) -> T): MutableList<T> {
    for (i in this) {
        this.add(_fun(i))   <---   ERROR
    }
    return this   <--- ERROR
}

决定

添加到新列表时效果很好:

fun <T> MutableList<T>.mathList(_fun: (T) -> T): MutableList<T> {
    val newList = mutableListOf<T>()   <---   DECISION
    for (i in this) {
        newList.add(_fun(i))   <---   DECISION
    }
    return newList   <---   DECISION
}

答案 20 :(得分:-2)

只需在您的 ArrayList.remove(A)语句之后添加 break