遍历Collection，避免在循环中删除对象时避免ConcurrentModificationException

我们都知道由于以下原因您无法执行以下操作ConcurrentModificationException：

for (Object i : l) {
    if (condition(i)) {
        l.remove(i);
    }
}

但这显然有时有效，但并非总是如此。这是一些特定的代码：

public static void main(String[] args) {
    Collection<Integer> l = new ArrayList<>();

    for (int i = 0; i < 10; ++i) {
        l.add(4);
        l.add(5);
        l.add(6);
    }

    for (int i : l) {
        if (i == 5) {
            l.remove(i);
        }
    }

    System.out.println(l);
}

当然，这导致：

Exception in thread "main" java.util.ConcurrentModificationException

即使没有多个线程。无论如何。

解决此问题的最佳方法是什么？如何在不引发此异常的情况下循环从集合中删除项目？

我还在Collection这里使用任意值，不一定是an ArrayList，因此您不能依赖get。

Iterator.remove() 是安全的，可以这样使用：

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

// This is a clever way to create the iterator and call iterator.hasNext() like
// you would do in a while-loop. It would be the same as doing:
//     Iterator<String> iterator = list.iterator();
//     while (iterator.hasNext()) {
for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
    String string = iterator.next();
    if (string.isEmpty()) {
        // Remove the current element from the iterator and the list.
        iterator.remove();
    }
}

注意，这Iterator.remove()是在迭代过程中修改集合的唯一安全方法。如果在进行迭代时以任何其他方式修改了基础集合，则行为未指定。

来源：docs.oracle>收集接口

同样，如果您有个ListIterator并想要添加项目，则可以使用ListIterator#add，出于与您可以使用的相同原因Iterator#remove -旨在允许它。

你的情况，你想从列表中删除，但同样的限制，如果想put成为一个Map在迭代的内容。

这有效：

Iterator<Integer> iter = l.iterator();
while (iter.hasNext()) {
    if (iter.next() == 5) {
        iter.remove();
    }
}

我假设因为foreach循环是用于迭代的语法糖，所以使用迭代器无济于事...但是它为您提供了此.remove()功能。

在Java 8中，可以使用新removeIf方法。应用于您的示例：

Collection<Integer> coll = new ArrayList<>();
//populate

coll.removeIf(i -> i == 5);

由于问题已经得到解决，即最好的方法是使用迭代器对象的remove方法，因此我将详细介绍"java.util.ConcurrentModificationException"引发错误的位置。

每个集合类都有它实现了Iterator接口，并提供了类似方法的私有类next()，remove()和hasNext()。

下一个代码看起来像这样...

public E next() {
    checkForComodification();
    try {
        E next = get(cursor);
        lastRet = cursor++;
        return next;
    } catch(IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
    }
}

这里的方法checkForComodification实现为

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

因此，如您所见，如果您明确尝试从集合中删除一个元素。结果导致与modCount变得不同expectedModCount，从而导致异常ConcurrentModificationException。

您可以像上面提到的那样直接使用迭代器，也可以保留另一个集合，然后将要删除的每个项目添加到新集合中，然后在最后删除removeAll。这使您能够以增加内存使用量和cpu时间为代价继续使用for-each循环的类型安全性（除非您拥有非常大的列表或非常老的计算机，否则这不是一个大问题）

public static void main(String[] args)
{
    Collection<Integer> l = new ArrayList<Integer>();
    Collection<Integer> itemsToRemove = new ArrayList<>();
    for (int i=0; i < 10; i++) {
        l.add(Integer.of(4));
        l.add(Integer.of(5));
        l.add(Integer.of(6));
    }
    for (Integer i : l)
    {
        if (i.intValue() == 5) {
            itemsToRemove.add(i);
        }
    }

    l.removeAll(itemsToRemove);
    System.out.println(l);
}

在这种情况下，通常的诀窍是（过去是）倒退：

for(int i = l.size() - 1; i >= 0; i --) {
  if (l.get(i) == 5) {
    l.remove(i);
  }
}

尽管如此，我很乐意，你必须在Java中8，如更好的方式removeIf或filter在流。

与Claudius的答案相同，带有for循环：

for (Iterator<Object> it = objects.iterator(); it.hasNext();) {
    Object object = it.next();
    if (test) {
        it.remove();
    }
}

使用Eclipse Collections时，MutableCollection上removeIf定义的方法将起作用：

MutableList<Integer> list = Lists.mutable.of(1, 2, 3, 4, 5);
list.removeIf(Predicates.lessThan(3));
Assert.assertEquals(Lists.mutable.of(3, 4, 5), list);

使用Java 8 Lambda语法，可以这样编写：

MutableList<Integer> list = Lists.mutable.of(1, 2, 3, 4, 5);
list.removeIf(Predicates.cast(integer -> integer < 3));
Assert.assertEquals(Lists.mutable.of(3, 4, 5), list);

Predicates.cast()此处需要进行调用，因为Java 8 removeIf的java.util.Collection接口上添加了默认方法。

注意：我是Eclipse Collections的提交者。

制作现有列表的副本，并遍历新副本。

for (String str : new ArrayList<String>(listOfStr))     
{
    listOfStr.remove(/* object reference or index */);
}

人们断言不能从被foreach循环迭代的Collection中删除。我只是想指出这在技术上是不正确的，并准确地描述了该假设背后的代码（我知道OP的问题非常先进，以至于不知道这一点）。

for (TouchableObj obj : untouchedSet) {  // <--- This is where ConcurrentModificationException strikes
    if (obj.isTouched()) {
        untouchedSet.remove(obj);
        touchedSt.add(obj);
        break;  // this is key to avoiding returning to the foreach
    }
}

不是您不能从迭代中删除，Colletion而是一旦完成就无法继续迭代。因此，break在上面的代码中。

抱歉，如果此答案是一个有点专业的用例，并且更适合于我从此处到达的原始线程，那该标记为该线程的副本（尽管此线程看上去更细微）并被锁定。

与传统的for循环

ArrayList<String> myArray = new ArrayList<>();

for (int i = 0; i < myArray.size(); ) {
    String text = myArray.get(i);
    if (someCondition(text))
        myArray.remove(i);
    else
        i++;   
}

A ListIterator允许您添加或删除列表中的项目。假设您有一个Car对象列表：

List<Car> cars = ArrayList<>();
// add cars here...

for (ListIterator<Car> carIterator = cars.listIterator();  carIterator.hasNext(); )
{
   if (<some-condition>)
   { 
      carIterator().remove()
   }
   else if (<some-other-condition>)
   { 
      carIterator().add(aNewCar);
   }
}

我对以上问题有一个建议。无需二级列表或任何额外的时间。请找到一个示例，该示例将执行相同的操作，但使用不同的方式。

//"list" is ArrayList<Object>
//"state" is some boolean variable, which when set to true, Object will be removed from the list
int index = 0;
while(index < list.size()) {
    Object r = list.get(index);
    if( state ) {
        list.remove(index);
        index = 0;
        continue;
    }
    index += 1;
}

这样可以避免并发异常。

ConcurrentHashMap或ConcurrentLinkedQueue或ConcurrentSkipListMap可能是另一个选择，因为即使您删除或添加项目，它们也不会抛出任何ConcurrentModificationException。

我知道这个问题对于Java 8来说已经太老了，但是对于那些使用Java 8的人来说，您可以轻松地使用removeIf（）：

Collection<Integer> l = new ArrayList<Integer>();

for (int i=0; i < 10; ++i) {
    l.add(new Integer(4));
    l.add(new Integer(5));
    l.add(new Integer(6));
}

l.removeIf(i -> i.intValue() == 5);

另一种方法是创建arrayList的副本：

List<Object> l = ...

List<Object> iterationList = ImmutableList.copyOf(l);

for (Object i : iterationList) {
    if (condition(i)) {
        l.remove(i);
    }
}

最好的方法（推荐）是使用java.util.Concurrent包。通过使用此包，您可以轻松避免此Exception。参考修改后的代码

public static void main(String[] args) {
    Collection<Integer> l = new CopyOnWriteArrayList<Integer>();

    for (int i=0; i < 10; ++i) {
        l.add(new Integer(4));
        l.add(new Integer(5));
        l.add(new Integer(6));
    }

    for (Integer i : l) {
        if (i.intValue() == 5) {
            l.remove(i);
        }
    }

    System.out.println(l);
}

在ArrayList：remove（int index）-if（index是最后一个元素的位置）的情况下System.arraycopy()，它避免了这种情况，并且不需要花费时间。

arraycopy时间增加if（index减少），通过list元素也减少！

最好的有效删除方法是-降序删除其元素： while(list.size()>0)list.remove(list.size()-1);//取O（1） while(list.size()>0)list.remove(0);//取O（factorial（n））

//region prepare data
ArrayList<Integer> ints = new ArrayList<Integer>();
ArrayList<Integer> toRemove = new ArrayList<Integer>();
Random rdm = new Random();
long millis;
for (int i = 0; i < 100000; i++) {
    Integer integer = rdm.nextInt();
    ints.add(integer);
}
ArrayList<Integer> intsForIndex = new ArrayList<Integer>(ints);
ArrayList<Integer> intsDescIndex = new ArrayList<Integer>(ints);
ArrayList<Integer> intsIterator = new ArrayList<Integer>(ints);
//endregion

// region for index
millis = System.currentTimeMillis();
for (int i = 0; i < intsForIndex.size(); i++) 
   if (intsForIndex.get(i) % 2 == 0) intsForIndex.remove(i--);
System.out.println(System.currentTimeMillis() - millis);
// endregion

// region for index desc
millis = System.currentTimeMillis();
for (int i = intsDescIndex.size() - 1; i >= 0; i--) 
   if (intsDescIndex.get(i) % 2 == 0) intsDescIndex.remove(i);
System.out.println(System.currentTimeMillis() - millis);
//endregion

// region iterator
millis = System.currentTimeMillis();
for (Iterator<Integer> iterator = intsIterator.iterator(); iterator.hasNext(); )
    if (iterator.next() % 2 == 0) iterator.remove();
System.out.println(System.currentTimeMillis() - millis);
//endregion

• 用于索引循环：1090毫秒
• 对于desc索引：519毫秒---最佳
• 对于迭代器：1043毫秒

for (Integer i : l)
{
    if (i.intValue() == 5){
            itemsToRemove.add(i);
            break;
    }
}

如果您跳过内部iterator.next（）调用，则从列表中删除该元素之后便是捕获。它仍然有效！尽管我不建议编写这样的代码，但有助于理解其背后的概念:-)

干杯!

线程安全集合修改的示例：

public class Example {
    private final List<String> queue = Collections.synchronizedList(new ArrayList<String>());

    public void removeFromQueue() {
        synchronized (queue) {
            Iterator<String> iterator = queue.iterator();
            String string = iterator.next();
            if (string.isEmpty()) {
                iterator.remove();
            }
        }
    }
}

我知道这个问题只是假设一个Collection，而不是假设任何一个List。但是对于那些确实在使用List引用的阅读此问题的人，可以避免ConcurrentModificationException使用while-loop（在其中进行修改），而不要避免Iterator（如果您想总体上避免它，或者专门为了实现而避免使用它）一个不同于在每个元素上从头到尾停止的循环顺序（我相信这是唯一Iterator可以执行的顺序））：

*更新：请参见下面的注释，以澄清类似情况也可以通过传统的 -for循环实现。

final List<Integer> list = new ArrayList<>();
for(int i = 0; i < 10; ++i){
    list.add(i);
}

int i = 1;
while(i < list.size()){
    if(list.get(i) % 2 == 0){
        list.remove(i++);

    } else {
        i += 2;
    }
}

该代码没有ConcurrentModificationException。

在这里，我们看到循环不是从头开始，也不是在每个元素上都停止（我相信Iterator它本身无法做到）。

FWIW我们也看到get被调用了list，如果它的引用只是Collection（而不是更具体的List类型Collection）-interface Listincludes get，但是Collectioninterface并不是，则无法完成。如果不是因为这种差异，则list参考可以改为Collection[因此，从技术上讲，此答案将是直接答案，而不是切向答案]。

FWIWW相同的代码经过修改后可以在每个元素的停止处开始（仍然像Iterator顺序）一样仍然有效：

final List<Integer> list = new ArrayList<>();
for(int i = 0; i < 10; ++i){
    list.add(i);
}

int i = 0;
while(i < list.size()){
    if(list.get(i) % 2 == 0){
        list.remove(i);

    } else {
        ++i;
    }
}

一种解决方案是旋转列表并删除第一个元素，以避免ConcurrentModificationException或IndexOutOfBoundsException

int n = list.size();
for(int j=0;j<n;j++){
    //you can also put a condition before remove
    list.remove(0);
    Collections.rotate(list, 1);
}
Collections.rotate(list, -1);

试试这个（删除列表中等于的所有元素i）：

for (Object i : l) {
    if (condition(i)) {
        l = (l.stream().filter((a) -> a != i)).collect(Collectors.toList());
    }
}

这可能不是最好的方法，但是对于大多数小情况，这应该可以接受：

“创建第二个空数组，并仅添加要保留的空数组”

_{我不记得我从哪里读来的……为了公正起见，我将制作此Wiki，以希望有人找到它或只是不赚我不配的代表。}