将多个Optional对象拼接为Stream<T>，有无更优实现方式？

Great question! Dealing with nested Stream.concat() calls quickly becomes unwieldy as you add more Optional instances—we’ve all been stuck with that messy nested syntax. Luckily, there are much cleaner, scalable approaches to solve this.

The Simplest Solution: Stream.of() + flatMap #

Instead of nesting Stream.concat() calls, you can use Stream.of() to gather all your Optionals into a single stream, then use flatMap() to expand each Optional into its underlying element stream (empty Optionals will just contribute an empty stream, which gets ignored automatically).

Here’s how it looks for your original 3 Optionals:

Optional<T> optA = getOptA();
Optional<T> optB = getOptB();
Optional<T> optC = getOptC();

Stream<T> combinedStream = Stream.of(optA, optB, optC)
                                 .flatMap(Optional::stream);

And scaling this to 4 (or even 10!) Optionals is trivial—just add them to the Stream.of() call:

Stream<T> combinedStream = Stream.of(optA, optB, optC, optD)
                                 .flatMap(Optional::stream);

Why This Works #

• Stream.of() accepts a variable number of arguments, so you can easily add/remove Optionals without restructuring your code.
• flatMap(Optional::stream) converts each Optional to a stream containing its value (if present) or an empty stream (if not). This behaves exactly like your original nested concat approach, preserving the order of elements from the input Optionals.

For Collections of Optionals #

If your Optionals are already stored in a collection (like a List or Set), you can skip the Stream.of() step and directly stream the collection:

List<Optional<T>> optionalList = Arrays.asList(optA, optB, optC, optD);
Stream<T> combinedStream = optionalList.stream()
                                       .flatMap(Optional::stream);

This is equally clean and scales seamlessly as your collection grows.

Comparison to Nested concat #

Your original approach works, but it’s not maintainable:

// Messy and hard to read with more than 2-3 elements
Stream.concat(Stream.concat(optA.stream(), optB.stream()), Stream.concat(optC.stream(), optD.stream()));

The Stream.of() + flatMap approach is far more readable, requires less code, and avoids the "pyramid of doom" nesting that comes with multiple concat calls.

内容的提问来源于stack exchange，提问作者Hendrik Janßen