1. Introduction
In Java, it’s straightforward to remove a specific value from a List using List.remove(). However, efficiently removing all occurrences of a value is much harder.
In this tutorial, we’ll see multiple solutions to this problem, describing the pros and cons.
For the sake of readability, we use a custom list(int…) method in the tests, which returns an ArrayList containing the elements we passed.
2. Using a while Loop
Since we know how to remove a single element, doing it repeatedly in a loop looks simple enough:
void removeAll(List<Integer> list, int element) {
while (list.contains(element)) {
list.remove(element);
}
}
However, it doesn’t work as expected:
// given List<Integer> list = list(1, 2, 3); int valueToRemove = 1; // when assertThatThrownBy(() -> removeAll(list, valueToRemove)) .isInstanceOf(IndexOutOfBoundsException.class);
The problem is in the 3rd line: we call List.remove(int), which treats its argument as the index, not the value we want to remove.
In the test above we always call list.remove(1), but the element’s index we want to remove is 0. Calling List.remove() shifts all elements after the removed one to smaller indices.
In this scenario, it means that we delete all elements, except the first.
When only the first remains, the index 1 will be illegal. Hence we get an Exception.
Note, that we face this problem only if we call List.remove() with a primitive byte, short, char or int argument, since the first thing the compiler does when it tries to find the matching overloaded method, is widening.
We can correct it by passing the value as Integer:
void removeAll(List<Integer> list, Integer element) {
while (list.contains(element)) {
list.remove(element);
}
}
Now the code works as expected:
// given List<Integer> list = list(1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(2, 3));
Since List.contains() and List.remove() both have to find the first occurrence of the element, this code causes unnecessary element traversal.
We can do better if we store the index of the first occurrence:
void removeAll(List<Integer> list, Integer element) {
int index;
while ((index = list.indexOf(element)) >= 0) {
list.remove(index);
}
}
We can verify that it works:
// given List<Integer> list = list(1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(2, 3));
While these solutions produce short and clean code, they still have poor performance: because we don’t keep track of the progress, List.remove() has to find the first occurrence of the provided value to delete it.
Also, when we use an ArrayList, element shifting can cause many reference copying, even reallocating the backing array several times.
3. Removing Until the List Changes
List.remove(E element) has a feature we didn’t mention yet: it returns a boolean value, which is true if the List changed because of the operation, therefore it contained the element.
Note, that List.remove(int index) returns void, because if the provided index is valid, the List always removes it. Otherwise, it throws IndexOutOfBoundsException.
With this, we can perform removals until the List changes:
void removeAll(List<Integer> list, int element) {
while (list.remove(element));
}
It works as expected:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(2, 3));
Despite being short, this implementation suffers from the same problems we described in the previous section.
3. Using a for Loop
We can keep track of our progress by traversing through the elements with a for loop and remove the current one if it matches:
void removeAll(List<Integer> list, int element) {
for (int i = 0; i < list.size(); i++) {
if (Objects.equals(element, list.get(i))) {
list.remove(i);
}
}
}
It works as expected:
// given List<Integer> list = list(1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(2, 3));
However, if we try it with a different input, it provides an incorrect output:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(1, 2, 3));
Let’s analyze how the code works, step-by-step:
- i = 0
- element and list.get(i) are both equal to 1 at line 3, so Java enters the body of the if statement,
- we remove the element at index 0,
- so list now contains 1, 2 and 3
- i = 1
- list.get(i) returns 2 because when we remove an element from a List, it shifts all proceeding elements to smaller indices
So we face this problem when we have two adjacent values, which we want to remove. To solve this, we should maintain the loop variable.
Decreasing it when we remove the element:
void removeAll(List<Integer> list, int element) {
for (int i = 0; i < list.size(); i++) {
if (Objects.equals(element, list.get(i))) {
list.remove(i);
i--;
}
}
}
Increasing it only when we don’t remove the element:
void removeAll(List<Integer> list, int element) {
for (int i = 0; i < list.size();) {
if (Objects.equals(element, list.get(i))) {
list.remove(i);
} else {
i++;
}
}
}
Note, that in the latter, we removed the statement i++ at line 2.
Both solutions work as expected:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(2, 3));
This implementation seems right for the first sight. However, it still has serious performance problems:
- removing an element from an ArrayList, shifts all items after it
- accessing elements by index in a LinkedList means traversing through the elements one-by-one until we find the index
4. Using a for-each Loop
Since Java 5 we can use the for-each loop to iterate through a List. Let’s use it to remove elements:
void removeAll(List<Integer> list, int element) {
for (Integer number : list) {
if (Objects.equals(number, element)) {
list.remove(number);
}
}
}
Note, that we use Integer as the loop variable’s type. Therefore we won’t get a NullPointerException.
Also, this way we invoke List.remove(E element), which expects the value we want to remove, not the index.
As clean as it looks, unfortunately, it doesn’t work:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when assertThatThrownBy(() -> removeWithForEachLoop(list, valueToRemove)) .isInstanceOf(ConcurrentModificationException.class);
The for-each loop uses Iterator to traverse through the elements. However, when we modify the List, the Iterator gets into an inconsistent state. Hence it throws ConcurrentModificationException.
The lesson is: we shouldn’t modify a List, while we’re accessing its elements in a for-each loop.
5. Using an Iterator
We can use the Iterator directly to traverse and modify the List with it:
void removeAll(List<Integer> list, int element) {
for (Iterator<Integer> i = list.iterator(); i.hasNext();) {
Integer number = i.next();
if (Objects.equals(number, element)) {
i.remove();
}
}
}
This way, the Iterator can track the state of the List (because it makes the modification). As a result, the code above works as expected:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(2, 3));
Since every List class can provide their own Iterator implementation, we can safely assume, that it implements element traversing and removal the most efficient way possible.
However, using ArrayList still means lots of element shifting (and maybe array reallocating). Also, the code above is slightly harder to read, because it differs from the standard for loop, that most developers are familiar with.
6. Collecting
Until this, we modified the original List object by removing the items we didn’t need. Rather, we can create a new List and collect the items we want to keep:
List<Integer> removeAll(List<Integer> list, int element) {
List<Integer> remainingElements = new ArrayList<>();
for (Integer number : list) {
if (!Objects.equals(number, element)) {
remainingElements.add(number);
}
}
return remainingElements;
}
Since we provide the result in a new List object, we have to return it from the method. Therefore we need to use the method in another way:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when List<Integer> result = removeAll(list, valueToRemove); // then assertThat(result).isEqualTo(list(2, 3));
Note, that now we can use the for-each loop since we don’t modify the List we’re currently iterating through.
Because there aren’t any removals, there’s no need to shift the elements. Therefore this implementation performs well when we use an ArrayList.
This implementation behaves differently in some ways than the earlier ones:
- it doesn’t modify the original List but returns a new one
- the method decides what the returned List‘s implementation is, it may be different than the original
Also, we can modify our implementation to get the old behavior; we clear the original List and add the collected elements to it:
void removeAll(List<Integer> list, int element) {
List<Integer> remainingElements = new ArrayList<>();
for (Integer number : list) {
if (!Objects.equals(number, element)) {
remainingElements.add(number);
}
}
list.clear();
list.addAll(remainingElements);
}
It works the same way the ones before:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(2, 3));
Since we don’t modify the List continually, we don’t have to access elements by position or shift them. Also, there’re only two possible array reallocations: when we call List.clear() and List.addAll().
7. Using the Stream API
Java 8 introduced lambda expressions and stream API. With these powerful features, we can solve our problem with a very clean code:
List<Integer> removeAll(List<Integer> list, int element) {
return list.stream()
.filter(e -> !Objects.equals(e, element))
.collect(Collectors.toList());
}
This solution works the same way, like when we were collecting the remaining elements.
As a result, it has the same characteristics, and we should use it to return the result:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when List<Integer> result = removeAll(list, valueToRemove); // then assertThat(result).isEqualTo(list(2, 3));
Note, that we can convert it to work like the other solutions with the same approach we did with the original ‘collecting’ implementation.
8. Using removeIf
With lambdas and functional interfaces, Java 8 introduced some API extensions, too. For example, the List.removeIf() method, which implements what we saw in the last section.
It expects a Predicate, which should return true when we want to remove the element, in contrast to the previous example, where we had to return true when we wanted to keep the element:
void removeAll(List<Integer> list, int element) {
list.removeIf(n -> Objects.equals(n, element));
}
It works like the other solutions above:
// given List<Integer> list = list(1, 1, 2, 3); int valueToRemove = 1; // when removeAll(list, valueToRemove); // then assertThat(list).isEqualTo(list(2, 3));
Due to the fact, that the List itself implements this method, we can safely assume, that it has the best performance available. On top of that, this solution provides the cleanest code of all.
9. Conclusion
In this article, we saw many ways to solve a simple problem, including incorrect ones. We analyzed them to find the best solution for every scenario.
As usual, the examples are available over on GitHub.