How to Avoid NoSuchElementException in Stream API

Last updated: January 8, 2024

Written by: Abderrahim Azhrioun

Reviewed by: Luis Javier Peris

Java Streams

Exception

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

In this short tutorial, we’ll explain how to avoid NoSuchElementException when working with the Stream API.

First, we’re going to explain the main cause of the exception. Then, we’ll showcase how to reproduce and fix it using practical examples.

2. The Cause of the Exception

Before delving deep into the details, let’s understand what the exception means.

In short, NoSuchElementException is thrown to signal that the requested element doesn’t exist. For instance, trying to access an element that is not available or present will lead to this exception.

Typically, calling the get() method on an empty Optional instance is one of the most common causes of NoSuchElementException when working with the Stream API.

3. Producing the Exception

Now that we know what the exception is, let’s go down the rabbit hole and see how to reproduce it in practice.

For example, let’s create a list of names and filter it using the Stream API:

@Test(expected = NoSuchElementException.class)
public void givenEmptyOptional_whenCallingGetMethod_thenThrowNoSuchElementException() {
    List<String> names = List.of("William", "Amelia", "Albert", "Philip");
    Optional<String> emptyOptional = names.stream()
      .filter(name -> name.equals("Emma"))
      .findFirst();

    emptyOptional.get();
}

As we can see, we used the filter() method to find the name “Emma”. Furthermore, we chained with the findFirst() method to get an Optional containing the first found element or an empty Optional if the filtered stream is empty.

Here, our list doesn’t contain the name “Emma”, so findFirst() returns an empty Optional. The test case fails with the NoSuchElementException exception because we’re trying to get a name that doesn’t exist and an empty Optional doesn’t hold any value.

4. Avoiding the Exception

Now, let’s see how to fix the exception. The easiest way would be to check if there’s a value present in our Optional instance before calling the get() method.

Fortunately, the Stream API provides the isPresent() method specifically for this purpose. So, let’s see it in action:

@Test
public void givenEmptyOptional_whenUsingIsPresentMethod_thenReturnDefault() {
    List<String> names = List.of("Tyler", "Amelia", "James", "Emma");
    Optional<String> emptyOptional = names.stream()
      .filter(name -> name.equals("Lucas"))
      .findFirst();

    String name = "unknown";
    if (emptyOptional.isPresent()) {
        name = emptyOptional.get();
    }

    assertEquals("unknown", name);
}

Here, we used isPresent() to make sure that there’s a value inside our Optional instance before calling the get() method. That way, we avoid the NoSuchElementException exception.

Please notice that the use of isPresent() comes with the cost of the if-else statements. So, can we do it better? Yes!

Typically, the best way to go is to use the orElse() method. In short, this method returns the value if it’s present, or the given fallback argument otherwise:

@Test
public void givenEmptyOptional_whenUsingOrElseMethod_thenReturnDefault() {
    List<String> names = List.of("Nicholas", "Justin", "James");
    Optional<String> emptyOptional = names.stream()
      .filter(name -> name.equals("Lucas"))
      .findFirst();

    String name = emptyOptional.orElse("unknown");

    assertEquals("unknown", name);
}

As shown above, this method offers a more convenient and straightforward way to avoid NoSuchElementException.

Alternatively, we can use the orElseGet() method to achieve the same outcome:

@Test
public void givenEmptyOptional_whenUsingOrElseGetMethod_thenReturnDefault() {
    List<String> names = List.of("Thomas", "Catherine", "David", "Olivia");
    Optional<String> emptyOptional = names.stream()
      .filter(name -> name.equals("Liam"))
      .findFirst();

    String name = emptyOptional.orElseGet(() -> "unknown");

    assertEquals("unknown", name);
}

Unlike orElse(), orElseGet() accepts a supplier as a parameter. Another key difference is that orElse() is executed in all cases, even if the Optional instance has a value. However, orElseGet() is only executed when the Optional value isn’t present.

Please note that our article on the difference between the orElse() and orElseGet() methods does a great job of covering the topic.

5. Best Practices to Avoid NoSuchElementException

In a nutshell, there are several key points to keep in mind when working with the Stream API to avoid the NoSuchElementException exception:

Always check if the returned stream/optional is not empty before calling the get() method.
Try to define a fallback value using orElse() or orElseGet().
Use a filter before calling any terminal operation on a stream.