The Collection.removeIf() method was introduced in Java 8, and it allows for the removal of items from a collection using a condition defined in a lambda expression.
The primary purpose of the Collection.removeIf() method in Java is to filter out elements from a collection based on a certain condition or predicate. It’s a more efficient and concise way of performing this type of operation than traditional for or iterator-based loops.
The method iterates over each element in the collection and checks whether it satisfies the condition described by the given Predicate. If the Predicate returns true for a particular element, removeIf() removes that element from the collection.
Here’s a simple example:
package org.kodejava.util;
import java.util.ArrayList;
import java.util.List;
public class CollectionRemoveIfExample {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
// Use removeIf method to remove all numbers greater than 2
numbers.removeIf(n -> n > 2);
System.out.println(numbers); // Outputs: [1, 2]
}
}
In this example, n -> n > 2 is a lambda expression that defines a Predicate, which returns true for all numbers greater than 2. The removeIf() method uses this Predicate to determine which elements to remove.
Please be aware that not all Collection implementations support the removeIf() method. For example, if you try to use it with an unmodifiable collection (like the ones returned by Collections.unmodifiableList()), it will throw an UnsupportedOperationException.
As removeIf() is a default method, it’s provided with a default implementation, and it’s available for use with any classes that implement the Collection interface (like ArrayList, HashSet, etc.) without requiring those classes to provide their own implementation.
However, classes can still override this method with their own optimized version if necessary. Here’s another example of removeIf() method:
package org.kodejava.util;
import java.util.ArrayList;
import java.util.List;
public class CollectionRemoveIfSecond {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
names.add("David");
names.add("Rosa");
// Remove names that start with 'B'
names.removeIf(name -> name.startsWith("B"));
System.out.println(names); // Outputs: [Alice, Charlie, David, Rosa]
}
}
Remember, it’s a bulk operation that can lead to a ConcurrentModificationException if the collection is modified while the operation is running (for example, removing an element from a collection while iterating over it with removeIf()), except if the collection is a Concurrent Collection.
In conclusion, the Collection.removeIf() default method provides a unified, efficient, and convenient way to remove items from a collection based on certain conditions.
