Java 17 OCP: I try to understand "Chaining Optionals"

[Nico van de Kamp]

I'm busy with reading and do some practicing for Java 17 OCP. I'm busy in Chapter 10 "Channing Optionals".
Suddenly out of the blue, there is line represented like

Optional<Integer> result = optional.flatMap(ChainingOptionals::calculator);

I can follow that flatMap must be used instead off map().

Than I was asking myself what would you do with it? What is possible to use it that makes the live easier...

I have made something, but that doesn't make really sense but, at least it compiles and it runs, but is just returning what passed in:

public class ChainingOptionals {
    public static Optional<? extends Integer> calculator(Integer optional ) {
        Optional<Integer> result = Optional.of(optional);
        return result;
    }
}

public class _07WorkingWithAdvancedStreamPipelineConcepts {

    public static void main(String[] args) {
        Optional<Integer> optionalInteger = Optional.of(1234);
        Optional<Integer> result = optionalInteger.flatMap(ChainingOptionals::calculator);
        System.out.println("result: " + result);
    }
}

No I try to do something like counting the length of a String, but this doesn't compile:

    public static Optional<? extends Number> calculator(String str ) {
        Optional<Integer> result = str.map(n -> "" + n)
            //.filter(s -> s.length() == 3)
            .stream()
            .count();                              // Terminal operation
        return result;
    }

And this overloaded method calling by:

Optional<Integer> optionalString = Optional.of("String");
        Optional<Integer> result = optionalString.flatMap(ChainingOptionals::calculator);

An Optional like Optional<Integer> does have one value, right. I mean it is not a List or Array something like that.
It's for me very hard to understand what can you do with it? In which situation would you use it?

For diehard java developers they think a stupid question, you must be creative to think what you should do with it, but as said, on this moment I don't see the advantage.

[Stephan van Hulst]

Let's say you have a type that has an optional property, and then the return type of THAT property also has an optional property:

interface Person {

  Optional<Animal> favoriteAnimal();

}

interface Animal {

  Optional<Snack> favoriteSnack();

}

Now, if you wanted to know the favorite snack of your favorite animal, you could do something like this:

Optional<Optional<Snack>> snack = person.favoriteAnimal().map(Animal::favoriteSnack);

This would be really cumbersome though, because snack is now an Optional wrapped in another Optional. Instead, you'd like it to be an Optional<Snack> that is empty when either the person has no favorite animal, or the animal has no favorite snack:

Optional<Snack> snack = person.favoriteAnimal().flatMap(Animal::favoriteSnack);

Admittedly, this doesn't happen a lot. I've only needed to do this in my code a handful of  times. Just remember, if you ever run into a situation where you end up with an Optional wrapped in another Optional, it's likely you should have called flatMap() somewhere instead of map().