Java Stream findFirst() vs. findAny()

Last updated: January 9, 2024

Written by: baeldung

Java Streams

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

The Java 8 Stream API introduced two methods that are often misunderstood: findAny() and findFirst().

In this quick tutorial, we’ll look at the difference between these two methods and when to use them.

Filtering a Stream of Optionals in Java

A quick and practical guide to filtering Streams of Optionals in Java 8 and Java 9

Primitive Type Streams in Java

A quick and practical guide to using Java 8 Streams with primitive types.

Iterable to Stream in Java

The article explains how to convert an Iterable to Stream and why the Iterable interface doesn't support it directly.

2. Using Stream.findAny()

As the name suggests, the findAny() method allows us to find any element from a Stream. We use it when we’re looking for an element without paying an attention to the encounter order:

The method returns an Optional instance, which is empty if the Stream is empty:

@Test
public void createStream_whenFindAnyResultIsPresent_thenCorrect() {
    List<String> list = Arrays.asList("A","B","C","D");

    Optional<String> result = list.stream().findAny();

    assertTrue(result.isPresent());
    assertThat(result.get(), anyOf(is("A"), is("B"), is("C"), is("D")));
}

In a non-parallel operation, it will most likely return the first element in the Stream, but there is no guarantee for this.

For maximum performance when processing the parallel operation, the result cannot be reliably determined:

@Test
public void createParallelStream_whenFindAnyResultIsPresent_thenCorrect()() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Optional<Integer> result = list
      .stream().parallel()
      .filter(num -> num < 4).findAny();

    assertTrue(result.isPresent());
    assertThat(result.get(), anyOf(is(1), is(2), is(3)));
}

3. Using Stream.findFirst()

The findFirst() method finds the first element in a Stream. So, we use this method when we specifically want the first element from a sequence.

When there is no encounter order, it returns any element from the Stream. According to the java.util.streams package documentation, “Streams may or may not have a defined encounter order. It depends on the source and the intermediate operations.”

The return type is also an Optional instance, which is empty if the Stream is empty too:

@Test
public void createStream_whenFindFirstResultIsPresent_thenCorrect() {

    List<String> list = Arrays.asList("A", "B", "C", "D");

    Optional<String> result = list.stream().findFirst();

    assertTrue(result.isPresent());
    assertThat(result.get(), is("A"));
}

The behavior of the findFirst method does not change in the parallel scenario. If the encounter order exists, it will always behave deterministically.