The Java Stream API includes several useful methods, among which findAny() and anyMatch() are two of the most commonly used. Although they serve different functions, both methods adhere to functional programming principles, allowing us to handle collections more efficiently. In this article, we will take a look at how findAny() and anyMatch() work, and compare their applications in various situations.
1. Overview of findAny()
The findAny() method is used to retrieve any element from a stream. It returns an Optional containing the found element or an empty Optional if the stream is empty. It is usually used when we want to retrieve a single element without any specific preference for which one.
Syntax
Optional<T> findAny()
Characteristics
- Returns an
Optional<T>containing some element from the Stream or an empty Optional if the Stream is empty. - It may return any element from the Stream; if the Stream is parallel, the returned element might not be the first element encountered in the original source.
Here’s a simple example demonstrating the use of findAny():
public class FindAnyExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Thomas", "Frank", "Charlie", "Diana");
// Using findAny() to get any name from the stream
Optional<String> anyName = names.stream()
.filter(name -> name.startsWith("C"))
.findAny();
anyName.ifPresent(System.out::println);
}
}
In this example, findAny() retrieves any name from the list that starts with “C“. Since there is only one match (“Charlie“), that is the output.
Output is:
Charlie
2. Overview of anyMatch()
The anyMatch() method checks whether any elements in the stream match a given predicate. It returns a boolean value indicating whether at least one element satisfies the condition. This method is helpful when you want to see if any element matches certain conditions without needing to get the actual element.
Syntax
boolean anyMatch(Predicate<? super T> predicate)
Characteristics
- Returns
trueif any elements of the Stream match the provided predicate; otherwise, it returnsfalse. - Short-circuits, meaning it stops processing as soon as it finds a matching element, which can lead to performance improvements.
Here’s an example demonstrating the use of anyMatch():
public class AnyMatchExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Thomas", "Frank", "Charlie", "Diana");
// Using anyMatch() to check if any name starts with 'C'
boolean hasNameStartingWithC = names.stream()
.anyMatch(name -> name.startsWith("C"));
System.out.println("Any name starts with 'C': " + hasNameStartingWithC);
}
}
In this example, we use the same list of names and convert it to a stream with the stream() method. We then apply the anyMatch() method, which uses a predicate to check if any names start with “C”. The result is a boolean value that tells us whether a name meeting this condition exists.
Output is:
Any name starts with 'C': true
3. Comparing findAny() and anyMatch()
While both methods are terminal operations, they serve different purposes:
| Feature | findAny() | anyMatch() |
|---|---|---|
| Return Type | Optional<T> | boolean |
| Purpose | Retrieve any single element from the Stream | Check if any element matches a condition |
| Behaviour | Returns an element (if present) | Returns true or false |
| Short-circuiting | No | Yes |
Use Cases
- Use
findAny()when you need to retrieve an arbitrary element from a Stream. - Use
anyMatch()when you need to check if any elements meet a specific condition without needing to retrieve the actual elements.
4. Related Methods
In addition to findAny() and anyMatch(), there are several other methods in the Streams API that complement these operations:
findFirst()
Similar to findAny(), findFirst() returns the first element of the stream that matches a predicate. It is not affected by parallel processing, ensuring the first element is always the first encountered.
public class RelatedMethodExamples {
public static void main(String[] args) {
List names = Arrays.asList("Thomas", "Frank", "Carol", "Charlie", "Diana");
Optional firstMatch = names.stream()
.filter(name -> name.startsWith("C"))
.findFirst();
firstMatch.ifPresent(name -> System.out.println("First match: " + name));
}
}
Output:
First match: Carol
count()
The count() method returns the number of elements in the stream that match a given condition.
long countCNames = names.stream()
.filter(name -> name.startsWith("C"))
.count();
System.out.println("Count of names starting with 'C': " + countCNames);
Output:
Count of names starting with 'C': 2
allMatch()
The allMatch() method checks if all elements in the stream match a given predicate, returning true if they do, otherwise false.
boolean allStartWithA = names.stream()
.allMatch(name -> name.startsWith("A"));
System.out.println("All names start with 'A': " + allStartWithA);
Output:
All names start with 'A': false
5. Conclusion
In this article, we explored the findAny() and anyMatch() methods in Java Streams, understanding their individual purposes and how they differ. We learned that findAny() is used to retrieve any matching element from a stream, while anyMatch() checks if any elements satisfy a given condition, returning a boolean result. Additionally, we touched on related methods like findFirst(), count(), and allMatch(), which complement these operations.
6. Download the Source Code
This was an article on Java Streams‘ findAny() and anyMatch() methods.
You can download the full source code of this example here: java streams findany anymatch
