Getting a ConcurrentModificationException thrown when removing an element from a java.util.List during list iteration?

@Test
public void testListCur(){
	List<String> li=new ArrayList<String>();
	for(int i=0;i<10;i++){
		li.add("str"+i);
	}
	
	for(String st:li){
		if(st.equalsIgnoreCase("str3"))
			li.remove("str3");
	}
	System.out.println(li);
}

When I run this code,I will throw a ConcurrentModificationException.

It looks as though when I remove the specified element from the list, the list does not know its size have been changed.

I'm wondering if this is a common problem with collections and removing elements?

I believe this is the purpose behind the Iterator.remove() method, to be able to remove an element from the collection while iterating.

For example:

Iterator<String> iter = li.iterator();
while(iter.hasNext()){
    if(iter.next().equalsIgnoreCase("str3"))
        iter.remove();
}

The Java 8 way to remove it from the List without Iterator is:

li.removeIf(<predicate>)

i.e.

List<String> li = new ArrayList<String>();
// ...
li.removeIf(st -> !st.equalsIgnoreCase("str3"));

> Note that this exception does not always indicate that an object has been concurrently modified by a different thread. If a single thread issues a sequence of method invocations that violates the contract of an object, the object may throw this exception. For example, if a thread modifies a collection directly while it is iterating over the collection with a fail-fast iterator, the iterator will thow this exception

Taken from http://download.oracle.com/javase/1.4.2/docs/api/java/util/ConcurrentModificationException.html

yes people run into it -- the problem is you can't modify the list while iterating over it. I have used 2 alternatives in the past:

1. You can keep track of the indexes of the items you want to remove, and then remove them after you are done iterating.
2. Or you can copy all the ones you want to keep into a new list as you iterate, and then discard the old list when done.

those options assume you have to iterate over the list to find the elements to remove -- useful in cases where the list elements are complex objects with properties you might test on.

In your particular case, you dont even need to iterate, as you can just use removeAll. Look at the API here. There are also nifty methods like retainAll that discard everything that is not in the argument. You can use remove/retain-like methods whenever the objects in the list implement equals and hashcode properly. If you cannot rely on equals/hashcode to identify equality between instances in your app, you will have to do the removal yourself....

Try this (Java 8):

list.removeIf(condition);

You could make a copy of list you want to remove element from, directly in for-each loop. For me, that is the simpliest way. Something like this:

for (String stringIter : new ArrayList<String>(myList)) {
    myList.remove(itemToRemove);
}

Hope that will help you..

I think it is worth mentioning the Java 8 version

@Test
public void testListCur() {
    List<String> li = new ArrayList<String>();
    for (int i = 0; i < 10; i++) {
        li.add("str" + i);
    }

    li = li.stream().filter(st -> !st.equalsIgnoreCase("str3")).collect(Collectors.toList());

    System.out.println(li);
}

ArrayList has field modCount - count of collection modifications

When you invoke method iterator() creates new object Itr. It has field expectedModCount. expectedModCount field initialize by modCount value. When you invoke

li.remove("str3");

modCount increments. When do you try access to li via iterator checks that expectedModCount == modCount

and if it is false throws ConcurrentModificationException

Hence if you get iterator and after collection modified - iterator is considered not valid and you cannot use it.

I think that best answer is from bigdev.de, but i would like to add something to it(like if the item is removed from a list, maybe you would like to log that somewhere or something):

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

list.removeIf(a -> {
                boolean condition = a.equalsIgnoreCase("some condition");
                if(condition)
                    logger.info("Item removed from the list: " + a);
                return condition;
  });

I got this problem and I think the easier way is the same with the second way that hvgotcodes gave.

> Or you can copy all the ones you want to keep into a new list as you iterate, and then discard the old list when done.

@Test
public void testListCur(){
    List<String> li=new ArrayList<String>();
    for(int i=0;i<10;i++){
        li.add("str"+i);
    }
    List<String> finalLi = new ArrayList<String>();
    for(String st:li){
        if(st.equalsIgnoreCase("str3")){
            // Do nothing
        } else {
            finalLi.add(st);
        }
    }
    System.out.println(finalLi);
}

I looped a different way...

public void testListCur(){
	List<String> li=new ArrayList<String>();
	for(int i=0;i<10;i++){
		li.add("str"+i);
	}

    for(int i=0; i<li.size(); i++)
        if(li.get(i).equalsIgnoreCase("str3"))
            li.remove(i--);

	System.out.println(li);
}