How do the flatMap methods in the Optional and Stream classes in Java compare?

The flatMap method in the Optional and Stream classes in Java serves a similar purpose — transforming and "flattening" nested structures, but is used in different contexts.

• In Stream<T>, the flatMap method takes a function that returns a stream (Stream<U>) for each element, and merges all these streams into a single flat stream (Stream<U>). This is useful when each element of the original stream can correspond to multiple elements in the resulting stream.

• In Optional<T>, the flatMap method takes a function that returns an Optional<U>, and if the original Optional is not empty, it returns the result of this function; otherwise, it returns an empty Optional. This avoids nested Optional<Optional<U>>.

Example for Stream:

List<List<String>> list = List.of(List.of("a", "b"), List.of("c", "d"));
List<String> flat = list.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList()); // ["a", "b", "c", "d"]

Example for Optional:

Optional<String> optional = Optional.of("123");
Optional<Integer> result = optional.flatMap(s -> {
    try {
        return Optional.of(Integer.parseInt(s));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
});

Thus, both methods "flatten" nested structures, but Stream.flatMap works with streams of elements, while Optional.flatMap works with nested optional values.