如何基于Supplier延迟创建Java 8 Stream，避免无消息时的不必要计算？

你的问题里有两个需要注意的点：一是当前代码会提前生成transformationsToApply流，不管有没有消息都执行过滤和映射操作；二是Java Stream只能被消费一次，你的代码里第一个消息处理完后，这个流就已经被遍历耗尽了，后续消息根本不会应用任何转换——这是个隐藏的bug哦。

下面是两种优化方案，都能实现「只有有消息需要处理时才生成转换逻辑，且所有消息复用同一套转换」的需求：

方案一：先收集有效消息，再按需生成转换列表 #

这个方案逻辑最直观，先把所有有效消息过滤出来，判断是否为空，为空直接返回；有消息时才生成转换列表（转成List方便复用）：

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

Message[] process(@Nullable Message[] messages) {
    // 先筛选出所有非空的有效消息，避免重复处理空值
    List<Message> validMessages = Arrays.stream(messages != null ? messages : new Message[0])
        .filter(Objects::nonNull)
        .collect(Collectors.toList());

    // 没有有效消息，直接返回空数组，完全跳过转换逻辑
    if (validMessages.isEmpty()) {
        return new Message[0];
    }

    // 有消息需要处理，才生成转换列表（转成List可重复遍历）
    List<Function<Message, Message>> transformationsToApply = transformations.stream()
        .filter(transformation -> transformationIsEnabled(transformation.getLeft()))
        .map(Pair::getRight)
        .collect(Collectors.toList());

    // 对每个有效消息应用所有转换
    return validMessages.stream()
        .map(agentMessage -> {
            transformationsToApply.forEach(transformation -> 
                processMessage(transformation, agentMessage));
            return agentMessage;
        })
        .toArray(Message[]::new);
}

方案二：用Supplier延迟生成转换列表（适合不想提前收集消息的场景） #

如果不想提前把消息收集到List里，可以用Supplier来包装转换逻辑的生成，只有确定有消息时才触发：

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

Message[] process(@Nullable Message[] messages) {
    // 用Supplier延迟生成转换列表，只有调用get()时才执行过滤和映射
    Supplier<List<Function<Message, Message>>> transformationsSupplier = () -> 
        transformations.stream()
            .filter(transformation -> transformationIsEnabled(transformation.getLeft()))
            .map(Pair::getRight)
            .collect(Collectors.toList());

    // 创建初始消息流
    Stream<Message> messageStream = Arrays.stream(messages != null ? messages : new Message[0])
        .filter(Objects::nonNull);

    // 检查是否有有效消息（注意：anyMatch会消费流，所以后续要重新创建）
    boolean hasMessages = messageStream.anyMatch(m -> true);
    if (!hasMessages) {
        return new Message[0];
    }

    // 有消息，获取转换列表
    List<Function<Message, Message>> transformationsToApply = transformationsSupplier.get();

    // 重新创建消息流并处理
    return Arrays.stream(messages != null ? messages : new Message[0])
        .filter(Objects::nonNull)
        .map(agentMessage -> {
            transformationsToApply.forEach(transformation -> 
                processMessage(transformation, agentMessage));
            return agentMessage;
        })
        .toArray(Message[]::new);
}

关键说明： #

1. 为什么用List而不是Stream：Java Stream是一次性的，一旦执行终端操作（比如forEach），流就会被关闭，无法再次遍历。转成List后可以重复给所有消息应用转换，解决了原代码的隐藏bug。
2. 延迟求值的实现：两种方案都是先判断是否有有效消息，只有存在时才执行转换逻辑的生成，完全避免了无消息时的不必要计算。

内容的提问来源于stack exchange，提问作者colymore