Chaining Optional and Stream in Java(preferably 11)

Question

I have a list of Foo objects, where each Foo contains a name and a List<Strings>.

I am trying to

1. find if the fooList contains a Foo object with a target name, and if such element exists,
2. find if a target set of strings is a subset of the List stringList in the found Foo instance.

This is the code I have yet.

import java.util.List;

public class Foo {
    String fooName;
    List<String> bars;

    public Foo(String fooName, List<String> bars) {
        this.fooName = fooName;
        this.bars = bars;
    }

    public String getFooName() {
        return fooName;
    }

    public List<String> getBars() {
        return bars;
    }
}

    @Test
    public boolean demo() {

        List<Foo> fooList = new ArrayList<>();
        // add foos and bars

        String fooNameToFind = "some-target-name";

        Set<String> barsToFind = new HashSet<>();
        // add to list of target bar names

        Optional<Foo> optionalFoo = fooList.stream()
                .filter(foo -> foo.getFooName().equals(fooNameToFind))
                .findFirst();

        if (optionalFoo.isEmpty()) {
            // have to log something here
            Logger.getAnonymousLogger().info("target foo not found");
            return false;
        }

        boolean success = optionalFoo.get().getBars().stream()
                .filter(barsToFind::remove)
                .anyMatch(__ -> barsToFind.isEmpty());

        if (!success) {
            Logger.getAnonymousLogger().info("no match for list of bar names for given foo name");
        }

        return success;
    }

I wish to log whenever I don't find either the target name or the list subset. As you can see, I am currently using .isEmpty() and .get(), which I want to avoid. Please let me know if there is a better way to chain these.

TIA

EDIT: How about using peek?

Answer 1

You are looking for Optional.map()

If a value is present, apply the provided mapping function to it, and if the result is non-null, return an Optional describing the result. Otherwise return an empty Optional.

and Optional.orElseGet()

Return the value if present, otherwise invoke other and return the result of that invocation.

public boolean demo() {
  //get optional foo
  return optionalFoo
          .map(foo -> {
            boolean result = foo.getBars()
                    .stream()
                    .filter(barsToFind::remove)
                    .anyMatch(__ -> barsToFind.isEmpty());
            if (!result) {
              //log stuff
            }
            return result;
          })
          .orElseGet(() -> {
            //log stuff
            return false;
          });
}

Answer 2

Using Optional.stream() you can probably do this easier, also without having to remove anything from the set:

boolean success = fooList.stream() // Stream<Foo>
        .filter(foo -> foo.getFooName().equals(fooNameToFind)) // Stream<Foo>
        .findFirst() // Optional<Foo>
        .stream() // Stream<Foo> - either 0 or 1 element
        .filter(foo -> foo.getBars().containsAll(barsToFind)) // Stream<Foo>
        .findAny() // either the Foo from findFirst(), or empty if bars don't match
        .isPresent();

I've tested this with 2 Foo instances. One didn't have a matching name, the other had a matching name and contained all of the bars (plus some more). That one was found. I then added a bar that wasn't in the list, and I got no results.

With logging added:

boolean success = fooList.stream() // Stream<Foo>
        .filter(foo -> foo.getFooName().equals(fooNameToFind)) // Stream<Foo>
        .findFirst() // Optional<Foo>
        .or(() -> {
            Logger.getAnonymousLogger().info("target foo not found");
            return Optional.empty();
        })
        .stream() // Stream<Foo> - either 0 or 1 element
        .filter(foo -> foo.getBars().containsAll(barsToFind)) // Stream<Foo>
        .findAny() // either the Foo from findFirst(), or empty if bars don't match
        .or(() -> {
            Logger.getAnonymousLogger().info("no match for list of bar names for given foo name");
            return Optional.empty();
        })
        .isPresent();

These calls to or will only evaluate the supplier if the current Optional is empty, and replace the current empty Optional with the result of the supplier. By returning Optional.empty() this is effectively doing nothing but logging.