Filtering a Stream of Optionals in Java (With Examples)

A quick and practical guide to filtering Streams of Optionals in Java 8 and Java 9 (With Examples).

1. Introduction

In this article, You'll be learning how to remove or filter the non-empty values from Stream of Optionals from Optional API.

Usually, you work with Stream of Strings or Stream of custom objects. But, there are some cases where you frequently work with Optional values.

Java 8 has come up with a new Optional API which is to avoid the NullPointerExceptions and others as well. Actually, our real value will be wrapped into an Optional instance.

Removing the empty or nullable values from the list can be done in multiple ways in Java 8 and Java 9 concepts.


We'll' be working on the List<Optional<String>> instance in this whole tutorial.

List<Optional<String>> optionalList = Arrays.asList(Optional.of("hello"), Optional.empty(), Optional.of("world"), Optional.empty(), Optional.of("welcome to JavaProgramTo.com blog"));

This list has 5 Optional values and among those 3 are having string values, reaming two are empty optional.

Our intention is to remove the empty values from the List of Optionals.

2. Java 8 - Using filter()

In the first approach, We use the stream filter() method that takes the Predicate condition.

In the predicate, Call one of the Optional methods isPresent() method returns if the value inside the optional is not null. Returns false if the value is null.

If the isPresent() returns true, next use Optional::get method to retrieve the actual value.

package com.javaprogramto.java8.streams.optionals.filtering;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class OptionalNonNullExample {

    public static void main(String[] args) {

        List<Optional<String>> optionalList = Arrays.asList(
                Optional.of("hello"),
                Optional.empty(),
                Optional.of("world"),
                Optional.empty(),
                Optional.of("welcome to JavaProgramTo.com blog"));

        List<String> nonEmptyValuesList = optionalList
                .stream()
                .filter(o -> o.isPresent())
                .map(Optional::get)
                .collect(Collectors.toList());

        System.out.println(nonEmptyValuesList);

    }
}

Output:

[[hello, world, welcome to JavaProgramTo.com blog]]

Look at the output, thas filtered out Empty Optional values from it and converted the Stream<Optional<String>> to List<String>.

3. Java 8 - Using flatMap()

In the second approach, Java 8 Stream API has another useful method flatMap() that returns Stream<T> and takes Function as an argument.

flatMap() is one of Stream intermediate operations.

In our example, we are using flatMap() method to covert non null Optional value to Stream<String> and empty Optional to Empty stream using Stream.empty() method.

package com.javaprogramto.java8.streams.optionals.filtering;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class OptionalNonNullFlatMapEample {

    public static void main(String[] args) {

        List<Optional<String>> optionalList = Arrays.asList(
                Optional.of("hello"),
                Optional.empty(),
                Optional.of("world"),
                Optional.empty(),
                Optional.of("welcome to"),
                Optional.of("JavaProgramTo.com"));

        System.out.println("optionalList values : "+optionalList);

        List<String> nonEmptyValuesList = optionalList
                .stream()
                .flatMap(optional -> optional.isPresent() ? Stream.of(optional.get()) : Stream.empty())
                .collect(Collectors.toList());

        System.out.println(nonEmptyValuesList);

    }
}

Output:

[optionalList values : [Optional[hello], Optional.empty, Optional[world], Optional.empty, Optional[welcome to], Optional[JavaProgramTo.com]]
[hello, world, welcome to, JavaProgramTo.com]]

Observe the output that printing the values before and after removing the empty Optional values.

Stream.of(optional.get()) --> This of() method of Stream API returns a Stream of given one value.

Stream.empty() --> Creates a empty string type Stream.

4. Java 9 Optional stream() method - Optional::stream

In the last approach, Java 9 has come up with a new method stream() in Optional class to covert an Optional into Stream.

This approach looks as same as above but we are going to use builtin function.

Optional.stream() --> If a value is present, returns a sequential Stream containing only that value, otherwise returns an empty Stream.

package com.javaprogramto.java8.streams.optionals.filtering;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class OptionalStreamFlatMapEample {

    public static void main(String[] args) {

        List<Optional<String>> optionalList = Arrays.asList(
                Optional.of("hello"),
                Optional.empty(),
                Optional.of("world"),
                Optional.empty(),
                Optional.of("welcome to"),
                Optional.of("JavaProgramTo.com"));

        System.out.println("optionalList values : "+optionalList);

        List<String> nonEmptyValuesList = optionalList
                .stream()
                .flatMap(Optional.stream())
                .collect(Collectors.toList());

        System.out.println(nonEmptyValuesList);

    }
}

5. Conclusion

In this article, You've seen how to remove the empty Optional values from Stream in Java 8 and Java 9.

Examples are shown with using filter(), flatMap() and Optional.stream() methods.

All the code is shown in this article is over GitHub.

You can download the project directly and can run in your local without any errors.

View on GitHub 

Download 

If you have any queries please post in the comment section.

Ref API

What is the difference between map() and flatMap()?