140

So, if I try to remove elements from a Java HashSet while iterating, I get a ConcurrentModificationException. What is the best way to remove a subset of the elements from a HashSet as in the following example?

Set<Integer> set = new HashSet<Integer>();

for(int i = 0; i < 10; i++)
    set.add(i);

// Throws ConcurrentModificationException
for(Integer element : set)
    if(element % 2 == 0)
        set.remove(element);

Here is a solution, but I don't think it's very elegant:

Set<Integer> set = new HashSet<Integer>();
Collection<Integer> removeCandidates = new LinkedList<Integer>();

for(int i = 0; i < 10; i++)
    set.add(i);

for(Integer element : set)
    if(element % 2 == 0)
        removeCandidates.add(element);

set.removeAll(removeCandidates);

Thanks!

Improve this question
0

7 Answers 7

Reset to default
207

You can manually iterate over the elements of the set:

Iterator<Integer> iterator = set.iterator();
while (iterator.hasNext()) {
    Integer element = iterator.next();
    if (element % 2 == 0) {
        iterator.remove();
    }
}

You will often see this pattern using a for loop rather than a while loop:

for (Iterator<Integer> i = set.iterator(); i.hasNext();) {
    Integer element = i.next();
    if (element % 2 == 0) {
        i.remove();
    }
}

As people have pointed out, using a for loop is preferred because it keeps the iterator variable (i in this case) confined to a smaller scope.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

I prefer for to while, but each to his/her own.
I also use for myself. I used while to hopefully make the example clearer.
I perfer for mostly because the iterator variable is then limited to the scope of the loop.
If while is used then the iterator's scope is larger than it needs to be.
I prefer the while because it looks cleaner to me. The scope of the iterator should not be an issue if you are factoring your code. See Becks book "Test Driven Development" or Fowler's "Refactoring" for more about factoring code.
|
30

The reason you get a ConcurrentModificationException is because an entry is removed via Set.remove() as opposed to Iterator.remove(). If an entry is removed via Set.remove() while an iteration is being done, you will get a ConcurrentModificationException. On the other hand, removal of entries via Iterator.remove() while iteration is supported in this case.

The new for loop is nice, but unfortunately it does not work in this case, because you can't use the Iterator reference.

If you need to remove an entry while iteration, you need to use the long form that uses the Iterator directly.

for (Iterator<Integer> it = set.iterator(); it.hasNext();) {
    Integer element = it.next();
    if (element % 2 == 0) {
        it.remove();
    }
}
Improve this answer

4 Comments

@Shouldn't your code actually call it.next()?
Thanks for that. Fixed.
At what point is 'element' instantiated?
Ugh. Fixed. Thanks.
20

Java 8 Collection has a nice method called removeIf that makes things easier and safer. From the API docs:

default boolean removeIf(Predicate<? super E> filter)
Removes all of the elements of this collection that satisfy the given predicate. 
Errors or runtime exceptions thrown during iteration or by the predicate 
are relayed to the caller.

Interesting note:

The default implementation traverses all elements of the collection using its iterator(). 
Each matching element is removed using Iterator.remove().

From: https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html#removeIf-java.util.function.Predicate-

Improve this answer

1 Comment

An example: integerSet.removeIf(integer-> integer.equals(5));
11

Like timber said - "Java 8 Collection has a nice method called removeIf that makes things easier and safer"

Here is the code that solve your problem:

set.removeIf((Integer element) -> {
    return (element % 2 == 0);
});

Now your set contains only odd values.

Improve this answer

Comments

10

you can also refactor your solution removing the first loop:

Set<Integer> set = new HashSet<Integer>();
Collection<Integer> removeCandidates = new LinkedList<Integer>(set);

for(Integer element : set)
   if(element % 2 == 0)
       removeCandidates.add(element);

set.removeAll(removeCandidates);
Improve this answer

4 Comments

I would not recommend this as it introduces a hidden temporal coupling.
@RomainF. - What do you mean by hidden temporal coupling? Do you mean thread safe? Second, neither I would recommend this but the solution does have its pro. Super easy to read and hence maintainable.
Yes, the for-loop produces a side effect, but I agree that it may be the most readable solution, unless you are using Java 8. Otherwise, just use "removeIf" method.
I think this answer misses the point that the first loop was only there to have a HashSet from which to remove certain elements.
5

Here's the more modern streams approach:

myIntegerSet.stream().filter((it) -> it % 2 != 0).collect(Collectors.toSet())

However, this makes a new set, so memory constraints might be an issue if it's a really huge set.

EDIT: previous version of this answer suggested Apache CollectionUtils but that was before steams came about.

Improve this answer

3 Comments

This answer really starts showing its age... There's a Java-8 way of doing this now which is arguably cleaner.
Is there a better method to use, or were you just referring to the ability to use a lambda in place of an anonymous inner class?
Here's the more modern way: myIntegerSet.stream().filter((it) -> it % 2 != 0).collect(Collectors.toSet())
2

An other possible solution:

for(Object it : set.toArray()) { /* Create a copy */
    Integer element = (Integer)it;
    if(element % 2 == 0)
        set.remove(element);
}

Or:

Integer[] copy = new Integer[set.size()];
set.toArray(copy);

for(Integer element : copy) {
    if(element % 2 == 0)
        set.remove(element);
}
Improve this answer

1 Comment

That (or creating an ArrayList out of the set) is the best solution if you happen to not only remove existing elements but also adding new ones to the set during the loop.