在遍历和删除ArrayList中的元素时如何避免java.util.ConcurrentModificationException

我有一个要迭代的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();

两种选择：

• 创建要删除的值的列表，将其添加到循环中的列表中，然后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();
    }
}

从ArrayList的JavaDocs

此类的迭代器和listIterator方法返回的迭代器是快速失败的：如果在创建迭代器之后的任何时间以任何方式对列表进行结构修改，除非通过迭代器自己的remove或add方法，否则迭代器将抛出ConcurrentModificationException。

您试图从高级“ for循环”中的列表中删除值，即使您应用了任何技巧（您在代码中所做的），也无法实现。更好的方法是按照此处其他建议对迭代器级别进行编码。

我想知道人们如何没有建议传统的for循环方法。

for( int i = 0; i < lStringList.size(); i++ )
{
    String lValue = lStringList.get( i );
    if(lValue.equals("_Not_Required"))
    {
         lStringList.remove(lValue);
         i--; 
    }  
}

这也可以。

您实际上应该只是以传统方式迭代数组

每次您从列表中删除元素时，之后的元素都会被向前推送。只要您不更改迭代元素之外的其他元素，以下代码就应该起作用。

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);
    }
}

在Java 8中，可以使用Collection接口，并通过调用removeIf方法来执行此操作：

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

更多信息可以在这里找到

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

因此，请尝试：

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

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

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]

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

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

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

您可以分两步执行此操作吗：在第一个循环中，当您遍历列表时，不要删除选定的元素，而是将其标记为要删除。为此，您可以简单地将这些元素（浅拷贝）复制到另一个元素中List。

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

这是一个示例，其中我使用其他列表添加要删除的对象，然后使用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));
}

而不是为每个循环使用，而是使用普通的for循环。例如，下面的代码在不给出java.util.ConcurrentModificationException的情况下删除了数组列表中的所有元素。您可以根据用例在循环中修改条件。

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

          e.remove(i);
        }

做这样简单的事情：

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

使用流的另一种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示例产生了一个不可变的列表，该列表可能是您想要的，也可能不是您想要的。

您也可以使用CopyOnWriteArrayList而不是ArrayList。这是从JDK 1.5开始的最新推荐方法。

就我而言，接受的答案不起作用，它会停止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方法删除了所有必需的项目。

“我应该先克隆列表吗？”

这将是最简单的解决方案，从克隆中删除，然后在删除后将克隆复制回去。

我的rummikub游戏的一个示例：

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();
}

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

list.clear()

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

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);
}

所有这一切都是为了从一个列表更新到另一个列表，您可以仅从一个列表进行更新，并且在方法更新中，您可以同时检查两个列表，还可以在列表之间擦除或添加元素。这意味着两个列表总是大小相同

使用迭代器代替数组列表

将集合转换为类型匹配的迭代器

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

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

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

怎么样

import java.util.Collections;

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

只需在ArrayList.remove（A）语句后添加一个中断