遍历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 ，不一定是ArrayList ，所以您不能依赖get 。

#1楼

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

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

#2楼

使用Eclipse Collections时，在removeIf定义的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的java.util.Collection接口上添加了默认的removeIf方法。

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

#3楼

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

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

#4楼

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

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

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

#5楼

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

//"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;
}

这样可以避免并发异常。

#6楼

这有效：

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

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

#7楼

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 ，而迭代其内容。

#8楼

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

public static void main(String[] args)
{Collection<Integer> l = new ArrayList<Integer>();Collection<Integer> itemsToRemove = 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));}for (Integer i : l){if (i.intValue() == 5)itemsToRemove.add(i);}l.removeAll(itemsToRemove);System.out.println(l);
}

#9楼

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

Collection<Integer> coll = new ArrayList<>();
//populatecoll.removeIf(i -> i == 5);

#10楼

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

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

就是说，我很高兴您在Java 8中有了更好的方法，例如removeIf或removeIf filter 。

#11楼

由于问题已经得到解决，即最好的方法是使用迭代器对象的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 。

#12楼

如果ArrayList：remove（int index） System.arraycopy() 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（factor（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毫秒

#13楼

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

#14楼

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

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

干杯!

#15楼

与传统的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++;}

#16楼

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

#17楼

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

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

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

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

#18楼

最好的方法（推荐）是使用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);}

#19楼

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

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

#20楼

我知道这个问题对于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);

#21楼

我知道这个问题只是假设一个Collection ，而不是假设任何List 。但是对于那些确实在使用List引用的阅读此问题的人，可以避免使用while -loop（在其中进行修改）时避免ConcurrentModificationException ，而如果您要避免使用Iterator （或者您通常希望避免使用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 （而不是更具体的Collection List type），则无法完成List接口包括get ，但Collection接口没有。如果不是因为这种差异，则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;}
}

#22楼

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

List<Object> l = ...List<Object> iterationList = ImmutableList.copyOf(l);for (Object i : iterationList) {if (condition(i)) {l.remove(i);}

}

#23楼

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

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

#24楼

尝试这一步（删除列表中等于i所有元素）：

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