java lambda - how to traverse optional list/stream of optionals

Question

Having an Optional List of Optional's like:

Optional<List<Optional<String>>> optionalList = Optional.of(
    Arrays.asList(
        Optional.empty(),
        Optional.of("ONE"),
        Optional.of("TWO")));

How to traverse optionalList to print out the string's ONE and TWO ?

What about having an Optional Stream of Optionals?

Optional<Stream<Optional<String>>> optionalStream = Optional.of(
    Stream.of(
        Optional.empty(),
        Optional.of("ONE"),
        Optional.of("TWO")));

Update: Thanks for answers, solution for optionalStream (non nested):

optionalStream
    .orElseGet(Stream::empty)
    .filter(Optional::isPresent)
    .map(Optional::get)
    .forEach(System.out::println);

You can also just map the Optional to a Stream instead of checking isPresent and getting the value yourself explicitly. Will be a bit more 'functional style'. — jbx
– jbx, Commented Aug 3, 2018 at 9:12
You should avoid storing Optional in collections, see Uses for Optional and Is it Worth it to Use 'Optional' in Collections? — Didier L
– Didier L, Commented Aug 3, 2018 at 14:04
@DidierL true, however this is still a valid exercise for the case of Stream<Optional<T>> which is much more common when the items in your collection are being mapped to an Optional<T> by some other function, so you end up with a Stream<Optional<T>>, which you then want to filter and convert to a Stream<T>. — jbx
– jbx, Commented Aug 3, 2018 at 15:33
Indeed, for me this was a valid case as well. Note that there is an Optional.stream() method introduced in Java 9 to avoid that (to combine with flatMap()). Finally, I would also avoid Optional<List> and Optional<Stream> as they are not very friendly to work with. Use empty lists/streams instead whenever possible as this makes far cleaner API's. — Didier L
– Didier L, Commented Aug 3, 2018 at 16:02

Thiyagu · Accepted Answer · 2018-08-03 08:51:38Z

15

First, check if the Optional is present. If yes, then stream the list and filter the non-empty ones and print each of them.

optionalList.ifPresent(list -> list.stream()
            .filter(Optional::isPresent)
            .map(Optional::get)
            .forEach(System.out::println));

Almost similar for the stream case too

optionalStream.ifPresent(stream -> stream
            .filter(Optional::isPresent)
            .map(Optional::get)
            .forEach(System.out::println));

edited Aug 3, 2018 at 8:51

answered Aug 3, 2018 at 8:26

Thiyagu

18k5 gold badges49 silver badges88 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Sara Vino Over a year ago

adding a .map(Optional::get) will print the string

jbx · Accepted Answer · 2018-08-06 08:20:04Z

12

If you can use Java 9, it can be done like this:

optionalList.ifPresent(list -> list.stream()
  .flatMap(Optional::stream)
  .forEach(System.out::println));

For a stream of optionals it would be the same, without the first .stream() call.

With Java 8 you don't have the Optional::stream method available so you can do it yourself:

optionalList.ifPresent(list -> list.stream()
  .flatMap(opt -> opt.map(Stream::of).orElseGet(Stream::empty))
  .forEach(System.out::println));

And for a Stream of Optionals it would look like this:

optionalStream.ifPresent(stream -> stream
  .flatMap(opt -> opt.map(Stream::of).orElseGet(Stream::empty))
  .forEach(System.out::println));

edited Aug 6, 2018 at 8:20

answered Aug 3, 2018 at 9:09

jbx

22.3k20 gold badges100 silver badges151 bronze badges

2 Comments

Sara Vino Over a year ago

tried for a stream of optionals omitting first .stream() call - but not working (java 8)

jbx Over a year ago

What do you mean doesn't work? Just tried the Java 8 version, with the first line replaced to: optionalStream.ifPresent(stream -> stream definitely works.

davidxxx · Accepted Answer · 2018-08-03 08:39:21Z

11

You can indeed stream the Option<String> and filter only non empty values.

Optional<List<Optional<String>>> optionalList = Optional.of(Arrays.asList(Optional.empty(), Optional.of("ONE"), Optional.of("TWO")));

optionalList.orElseGet(ArrayList::new)
            .stream()
            .filter(Optional::isPresent)
            .map(Optional::get)           
            .forEach(System.out::println);

You can also use Optional.ifPresent() as suggested in another answers :

optionalList.ifPresent(l -> l.stream()
                             .filter(Optional::isPresent)
                             .map(Optional::get)                               
                             .forEach(System.out::println));

Personally I prefer the first way because it removes a nested level : I find it more pleasant to read.

edited Aug 3, 2018 at 8:39

answered Aug 3, 2018 at 8:31

davidxxx

132k23 gold badges231 silver badges228 bronze badges

4 Comments

jbx Over a year ago

The first way will create an empty ArrayList for nothing if the list does not exist.

davidxxx Over a year ago

It is right. But creating an empty ArrayList living in the scope of a stream execution costs also nothing.

chrylis -cautiouslyoptimistic- Over a year ago

I don't have an IDE handy, but wouldn't a flatMap squash the need for all of the isPresent checks?

jbx Over a year ago

@chrylis Yes. All these answers are so bloated, when all one needs to do is convert the Optional items in the list to a Stream and flatMap to it.

A. S. Ranjan · Accepted Answer · 2020-08-21 14:28:00Z

8

optionalList.stream().flatMap(List::stream).filter(Objects::nonNull).forEach(...)

answered Aug 21, 2020 at 14:28

A. S. Ranjan

4286 silver badges5 bronze badges

1 Comment

Rangi Keen Over a year ago

This version is nice because it avoids the creation of an empty list and skips right to the empty stream (but is only possible in Java 9+ when Optional.stream was introduced).

Rostislav V · Accepted Answer · 2019-10-08 06:12:33Z

As I see there are two ways, second one look a bit more pretty to me, take a look:

class Scratch {
    public static void main(String[] args) {
        Optional<String> element1 = Optional.of("test1");
        Optional<String> element2 = Optional.empty();
        Optional<String> element3 = Optional.of("test2");
        Optional<String> element4 = Optional.of("test3");
        List<Optional<String>> list = Arrays.asList(element1, element2, element3, element4);

        System.out.println(extractStrings1(list));
        System.out.println(extractStrings2(list));
    }

    private static List<String> extractStrings1(List<Optional<String>> list) {
        return list.stream()
                .filter(Optional::isPresent)
                .map(Optional::get)
                .collect(Collectors.toList());
    }

    private static List<String> extractStrings2(List<Optional<String>> list) {
        List<String> result = new ArrayList<>();
        list.forEach(element -> element.ifPresent(result::add));
        return result;
    }
}

Seelenvirtuose · Accepted Answer · 2018-08-03 08:25:42Z

2

Well ...

Check whether the optional list is present.
Do a "for each" for all elements of the (now present) list.
In each step check whether the optional string is present.
If yes, print it.

A one-liner can do that:

optionalList.ifPresent(list -> list.forEach(s -> s.ifPresent(System.out::println)));

answered Aug 3, 2018 at 8:25

Seelenvirtuose

20.7k6 gold badges40 silver badges69 bronze badges

Collectives™ on Stack Overflow

java lambda - how to traverse optional list/stream of optionals

6 Answers 6

1 Comment

2 Comments

4 Comments

1 Comment

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

1 Comment

2 Comments

4 Comments

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related