Removing objects from a collection in a loop without causing ConcurrentModificationException

This works:

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

I assumed that since a foreach loop is syntactic sugar for iterating, using an iterator wouldn't help... but it gives you this .remove() functionality.

With Java 8 you can use the new removeIf method. Applied to your example:

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

A simple test as example:

 @Test public void testRemoveIfOneList() { List<String> outer = new ArrayList<>(); outer.add("one"); outer.add("two"); outer.add("three"); outer.removeIf(o -> o.length() == 3); assertEquals(1, outer.size()); } 

It even works when you compare two lists and want to remove from both.

 @Test public void testRemoveIfTwoLists() { List<String> outer = new ArrayList<>(); outer.add("one"); outer.add("two"); outer.add("three"); List<String> inner = new ArrayList<>(); inner.addAll(outer); // first, it removes from inner, and if anything is removed, then removeIf() returns true, // leading to removing from outer outer.removeIf(o -> inner.removeIf(i -> i.equals(o))); assertEquals(0, outer.size()); assertEquals(0, inner.size()); } 

However, if one of the list has duplicates, make sure it's iterated in the inner loop, because for inner list, it will remove all elements meeting the criteria, but for outer list, when any element is removed, it will return immediately and stops checking.

This test will fail:

 @Test public void testRemoveIfTwoListsInnerHasDuplicates() { List<String> outer = new ArrayList<>(); outer.add("one"); outer.add("one"); outer.add("two"); outer.add("two"); outer.add("three"); outer.add("three"); List<String> inner = new ArrayList<>(); inner.addAll(outer); // both have duplicates // remove all elements from inner(executed twice), then remove from outer // but only once! if anything is removed, it will return immediately!! outer.removeIf(o -> inner.removeIf(i -> i.equals(o))); assertEquals(0, inner.size()); // pass, inner all removed assertEquals(0, outer.size()); // will fail, outer has size = 3 } 

Since the question has been already answered i.e. the best way is to use the remove method of the iterator object, I would go into the specifics of the place where the error "java.util.ConcurrentModificationException" is thrown.

Every collection class has a private class which implements the Iterator interface and provides methods like next(), remove() and hasNext().

The code for next looks something like this...

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

Here the method checkForComodification is implemented as

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

So, as you can see, if you explicitly try to remove an element from the collection. It results in modCount getting different from expectedModCount, resulting in the exception ConcurrentModificationException.

You can either use the iterator directly like you mentioned, or else keep a second collection and add each item you want to remove to the new collection, then removeAll at the end. This allows you to keep using the type-safety of the for-each loop at the cost of increased memory use and cpu time (shouldn't be a huge problem unless you have really, really big lists or a really old computer)

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

In such cases a common trick is (was?) to go backwards:

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

That said, I'm more than happy that you have better ways in Java 8, e.g. removeIf or filter on streams.

Same answer as Claudius with a for loop:

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

Make a copy of existing list and iterate over new copy.

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

With Eclipse Collections, the method removeIf defined on MutableCollection will work:

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

With Java 8 Lambda syntax this can be written as follows:

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

The call to Predicates.cast() is necessary here because a default removeIf method was added on the java.util.Collection interface in Java 8.

Note: I am a committer for Eclipse Collections.

People are asserting one can't remove from a Collection being iterated by a foreach loop. I just wanted to point out that is technically incorrect and describe exactly (I know the OP's question is so advanced as to obviate knowing this) the code behind that assumption:

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

It isn't that you can't remove from the iterated Colletion rather that you can't then continue iteration once you do. Hence the break in the code above.

Apologies if this answer is a somewhat specialist use-case and more suited to the original thread I arrived here from, that one is marked as a duplicate (despite this thread appearing more nuanced) of this and locked.

With a traditional for loop

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

ConcurrentHashMap or ConcurrentLinkedQueue or ConcurrentSkipListMap may be another option, because they will never throw any ConcurrentModificationException, even if you remove or add item.

Another way is to use a copy of your arrayList just for iteration:

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

A ListIterator allows you to add or remove items in the list. Suppose you have a list of Car objects:

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

Now, You can remove with the following code

l.removeIf(current -> current == 5); 

I know this question is too old to be about Java 8, but for those using Java 8 you can easily use 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); 

Java Concurrent Modification Exception

1. Single thread

Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String value = iter.next() if (value == "A") { list.remove(it.next()); //throws ConcurrentModificationException } } 

Solution: iterator remove() method

Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String value = iter.next() if (value == "A") { it.remove() } } 

2. Multi thread

• copy/convert and iterate over another one collection. For small collections
• synchronize^[About]
• thread safe collection^[About]

I have a suggestion for the problem above. No need of secondary list or any extra time. Please find an example which would do the same stuff but in a different way.

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

This would avoid the Concurrency Exception.

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

The catch is the after removing the element from the list if you skip the internal iterator.next() call. it still works! Though I dont propose to write code like this it helps to understand the concept behind it :-)

Cheers!

Example of thread safe collection modification:

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

I know this question assumes just a Collection, and not more specifically any List. But for those reading this question who are indeed working with a List reference, you can avoid ConcurrentModificationException with a while-loop (while modifying within it) instead if you want to avoid Iterator (either if you want to avoid it in general, or avoid it specifically to achieve a looping order different from start-to-end stopping at each element [which I believe is the only order Iterator itself can do]):

*Update: See comments below that clarify the analogous is also achievable with the traditional-for-loop.

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

No ConcurrentModificationException from that code.

There we see looping not start at the beginning, and not stop at every element (which I believe Iterator itself can't do).

FWIW we also see get being called on list, which could not be done if its reference was just Collection (instead of the more specific List-type of Collection) - List interface includes get, but Collection interface does not. If not for that difference, then the list reference could instead be a Collection [and therefore technically this Answer would then be a direct Answer, instead of a tangential Answer].

FWIWW same code still works after modified to start at beginning at stop at every element (just like Iterator order):

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

One solution could be to rotate the list and remove the first element to avoid the ConcurrentModificationException or 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); 

Try this one (removes all elements in the list that equal i):

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

You can use a while loop.

Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator(); while(iterator.hasNext()){ Map.Entry<String, String> entry = iterator.next(); if(entry.getKey().equals("test")) { iterator.remove(); } } 

I ended up with this ConcurrentModificationException, while iterating the list using stream().map() method. However the for(:) did not throw the exception while iterating and modifying the the list.

Here is code snippet , if its of help to anyone: here I'm iterating on a ArrayList<BuildEntity> , and modifying it using the list.remove(obj)

 for(BuildEntity build : uniqueBuildEntities){ if(build!=null){ if(isBuildCrashedWithErrors(build)){ log.info("The following build crashed with errors , will not be persisted -> \n{}" ,build.getBuildUrl()); uniqueBuildEntities.remove(build); if (uniqueBuildEntities.isEmpty()) return EMPTY_LIST; } } } if(uniqueBuildEntities.size()>0) { dbEntries.addAll(uniqueBuildEntities); } 

If using HashMap, in newer versions of Java (8+) you can select each of 3 options:

public class UserProfileEntity { private String Code; private String mobileNumber; private LocalDateTime inputDT; // getters and setters here } HashMap<String, UserProfileEntity> upMap = new HashMap<>(); // remove by value upMap.values().removeIf(value -> !value.getCode().contains("0005")); // remove by key upMap.keySet().removeIf(key -> key.contentEquals("testUser")); // remove by entry / key + value upMap.entrySet().removeIf(entry -> (entry.getKey().endsWith("admin") || entry.getValue().getInputDT().isBefore(LocalDateTime.now().minusMinutes(3))); 

The best way (recommended) is use of java.util.concurrent package. By using this package you can easily avoid this exception. Refer Modified Code:

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

Iterators are not always helpful when another thread also modifies the collection. I had tried many ways but then realized traversing the collection manually is much safer (backward for removal):

for (i in myList.size-1 downTo 0) { myList.getOrNull(i)?.also { if (it == 5) myList.remove(it) } } 

Iterator is not foolproof and can also cause ConcurrentModificationException in some cases.

This will work if single thread is accessing list at a time.

 val items = arrayListOf<String>() val itemsToBeRemoved = arrayListOf<String>() items.add("1") items.add("2") items.add("3") items.forEach { if(someCondition){ // item you want to be removed itemsToBeRemoved.add(it) } } itemsToBeRemoved.forEach { // remove item items.remove(it) } itemsToBeRemoved.clear() 

You can use CopyOnWriteArrayList if your list is access from mutliple threads. But remember it will cause performance issues if your list is changing frequently. CopyOnWriteArrayList will perform better if your list is not updating frequently.

In case ArrayList:remove(int index)- if(index is last element's position) it avoids without System.arraycopy() and takes not time for this.

arraycopy time increases if(index decreases), by the way elements of list also decreases!

the best effective remove way is- removing its elements in descending order: while(list.size()>0)list.remove(list.size()-1);//takes O(1) while(list.size()>0)list.remove(0);//takes 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 

• for index loop: 1090 msec
• for desc index: 519 msec---the best
• for iterator: 1043 msec