Java Optional stream 过滤空结果并保持顺序的方案

处理一批可能没有结果的查询时，最容易出现两类问题：空值被当成普通对象继续传递，或者为了过滤空值使用多层 isPresent() 和 get()，最后又把原来的顺序弄丢。对于一个有定义遭遇顺序的 List>，更直接的方案是把每个 Optional 转成 0 或 1 个元素的流，再用 flatMap(Optional::stream) 展平，最后用 toList() 收集。

官方地址：https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/Optional.html

核心写法是 optionals.stream().flatMap(Optional::stream).toList()。空 Optional 不会产生元素，有值 Optional 只产生一个元素；只要源集合本身有遭遇顺序，顺序收集就会得到与源一致的非空结果。

先看清 Optional.stream() 的输入输出

Optional.stream() 不会把 Optional 对象本身放进结果，而是返回一个顺序流：有值时包含一个值，空值时是空流。这正好把“有没有结果”转换成“贡献一个元素还是不贡献元素”。

import java.util.Optional;

public class OptionalStreamBasics {
    public static void main(String[] args) {
        // 有值 Optional 贡献一个元素，空 Optional 贡献零个元素。
        long presentCount = Optional.of("A").stream().count();
        long emptyCount = Optional.empty().stream().count();

        System.out.println(presentCount); // 1
        System.out.println(emptyCount);   // 0
    }
}

因此，过滤空结果不需要先调用 get()。如果数据源是 Stream>，下一步应该考虑“展平”，而不是把每个 Optional 当成普通对象过滤。

用 flatMap 过滤空结果并保持 List 顺序

假设查询结果按请求顺序返回，部分请求没有匹配项。flatMap(Optional::stream) 会把每个 Optional 的内部流拼接到同一条流中，空流自然不会贡献元素，有值流则贡献对应值。

import java.util.List;
import java.util.Optional;

public class OrderedOptionalValues {
    public static void main(String[] args) {
        List> optionals = List.of(
                Optional.of("A"),
                Optional.empty(),
                Optional.of("C")
        );

        // List 是有遭遇顺序的源；flatMap 只展开存在的值。
        List values = optionals.stream()
                .flatMap(Optional::stream)
                .toList();

        // 结果只包含非空值，并保持 A 在 C 之前。
        System.out.println(values); // [A, C]
    }
}

这里的“保持顺序”来自两个条件：源 List 有定义的遭遇顺序，且后续操作没有显式调用 unordered()。flatMap 负责展开，不负责重新排序；它不会把 A 和 C 按字典序重排。

不要用 get() 代替展平

下面的写法虽然能在当前数据下工作，但把空值判断和取值拆开了。只要后续维护者漏掉一次判断，就会在空 Optional 上触发 NoSuchElementException，也不利于继续组合流操作。

import java.util.List;
import java.util.Optional;

public class OptionalAntiPattern {
    public static void main(String[] args) {
        List> optionals = List.of(Optional.of("A"), Optional.empty());

        // 这个分支容易被复制成 get()，并把空值处理散落到多处。
        List values = optionals.stream()
                .filter(Optional::isPresent)
                .map(Optional::get)
                .toList();

        System.out.println(values); // [A]
    }
}

filter(Optional::isPresent).map(Optional::get) 并非一定错误，但它表达的是“先保留容器，再手动取值”；flatMap(Optional::stream) 表达的则是“把每个容器转换成 0 或 1 个值”。对于这类任务，后者更接近数据流的真实形状，也不需要暴露 get() 的异常边界。

顺序真正由源和终结操作决定

如果改成并行流，仍然可以让收集器遵守有序源的遭遇顺序，但不要用 forEach() 把顺序要求交给副作用执行。forEach() 在并行流上明确不保证遭遇顺序；只在确实需要按顺序消费时使用 forEachOrdered()，或者直接保留顺序流。

import java.util.List;
import java.util.Optional;

public class OrderedTerminalOperation {
    public static void main(String[] args) {
        List> optionals = List.of(
                Optional.of("A"), Optional.empty(), Optional.of("C")
        );

        // 收集 List 的非空值；toList() 适合需要稳定结果集合的场景。
        List stable = optionals.parallelStream()
                .flatMap(Optional::stream)
                .toList();

        // 需要按遭遇顺序执行副作用时，使用 forEachOrdered。
        stable.stream().forEachOrdered(value -> System.out.println(value));
    }
}

如果源是 HashSet 或者中途显式调用了 unordered()，就不能把“当前看起来的顺序”当成契约。要稳定返回列表，优先使用有序的 List；要并行执行副作用，则重新确认业务是否真的要求顺序。

封装成业务方法时保留边界

如果同一种转换在多个服务中出现，可以把输入类型明确写成 List>，让调用方知道顺序来自输入集合，而不是来自 Optional 自身。返回值使用不可变列表也能避免后续代码误改结果。

import java.util.List;
import java.util.Optional;

public final class OptionalValues {
    private OptionalValues() {
        // 工具类不需要实例化。
    }

    public static  List presentValues(List> source) {
        // 不改变 source；按输入 List 的遭遇顺序收集所有存在的值。
        return source.stream()
                .flatMap(Optional::stream)
                .toList();
    }
}

这个封装不负责去重、排序或补默认值。如果业务还要求去重，应显式增加 distinct()；如果要求排序，应显式增加 sorted()，不要把这些语义隐藏在“过滤空结果”的方法名里。

速查：什么时候能依赖顺序

常见问题

Optional.empty() 会在结果中留下 null 吗？

不会。Optional.empty().stream() 是空流，不会产生元素，也不会自动产生 null。

为什么不用 findAny()？

findAny() 只适合任取一个结果的场景，并行执行时结果不保证稳定；需要第一个遭遇值时使用 findFirst()，需要全部非空值时使用展平后收集。

flatMap 会自动排序吗？

不会。它只把每个 Optional 的 0/1 个元素合并到流中。排序需要显式调用 sorted()，稳定性首先取决于源是否有遭遇顺序。