🎯 Stream Gatherers：Java 24 终于补上了 Stream API 的“最后一块拼图”

*十年磨一剑。自 Java 8 引入 Stream，我们写下了无数 map- filter- collect；但每当业务稍复杂一点，那句熟悉的叹息便又响起——

“算了，还是 for 循环吧。”*

Java 24 的 Stream Gatherers，就是对这声叹息的正式回应。

🌊 Stream 的辉煌与隐痛

Stream API 是 Java 8 最成功的特性之一——它让数据处理声明式、惰性求值、并行透明，彻底改变了 Java 开发者的思维范式。

但光鲜背后，一个设计缺口始终存在：

中间操作（Intermediate Ops）是封闭的。

你可以用 mapfilterflatMap……

但你不能定义自己的中间操作。

这就像给了你一套乐高积木，却不允许你新增任何零件——

再精巧的建筑，也受限于盒子里已有的形状。

🔍 三大“憋屈时刻”：我们为何总想逃回 for 循环？

💡 场景一：按“属性”去重？不存在的！


// 理想写法（但编译不过）：

Stream.of("hello", "java", "hi", "world")

      .distinctBy(String::length)  // ← 不存在！

      .toList(); // 期望：["hello", "java"]（长度 5 和 4）

现实解法：


Stream.of("hello", "java", "hi", "world")

      .map(s -> new LengthWrapper(s))          // 包装

      .distinct()                               // 用 wrapper 的 equals/hashCode

      .map(LengthWrapper::value)                // 再拆包

      .toList();

📌 问题：逻辑简单，代码冗长distinct 本该是“描述意图”，却变成了“绕路施工”。

🪟 场景二：无限流 + 窗口分组？噩梦开始

需求：将 0,1,2,3,4,5,… 按每 3 个一组，取前 2 组 → [[0,1,2], [3,4,5]]

理想流式写法（自然、声明式）：


Stream.iterate(0, n -> n + 1)

      .windowFixed(3)   // ← 不存在！

      .limit(2)

      .toList();

现实解法（痛苦）：


Stream.iterate(0, n -> n + 1)

      .limit(6) // ← 必须手动计算：2 组 × 3 = 6？耦合了业务逻辑！

      .collect(/* 60 行 Collector，还不支持并行 */);

📌 痛点：本质是中间阶段的分组逻辑，却被塞进终止操作，无限流直接被“阉割”。

📈 场景三：相邻元素分析？Collector 已“超载”

需求：从温度序列中找出“相邻两次读数突变 >30°C” 的异常点。

理想写法：


readings.stream()

        .pairwise()           // ← 不存在！

        .filter(this::isSuspicious)

        .toList();

现实选择：

✅ 写 for 循环（清晰，但放弃声明式）
❌ 硬塞进 Collector（混乱、无法短路、强顺序）

此时的 Collector 已不再是“收集器”，而是：

🔴 被迫兼任：状态机 + 中间变换器 + 结果构建器

它在替 Stream API 的“缺失”还债。

🧩 破局者登场：Stream Gatherers（Java 24）

gather()：中间操作版的 collect()*

它不是新增一堆 API，而是——开放整个中间层的扩展能力。


Stream<T> gather(Gatherer<? super T, A, ? extends R>)

🧠 Gatherer 是什么？—— 四要素模型

| 组件 | 作用 | 类比 |

|------|------|------|

| Initializer | 创建私有状态（如窗口 buffer） | 🏗️ 场地搭建 |

| Integrator | 接收元素，更新状态，决定输出 & 是否继续 | 🧑‍🔧 核心工人 |

| Combiner | 并行流下合并子状态 | 🤝 协同调度 |

| Finisher | 流结束后的收尾（如 flush 剩余数据） | 🧹 清场收工 |

✅ 关键优势：

一进一出map）、一进多出flatMap）、多进一出reduce）、多进多出window）——全支持

可持有状态、可短路、可控并行性

所有现有中间操作，都是 Gatherer 的特例！

🚀 实战：终于可以“流”着写了！

✅ 1. 按属性去重 → 内置 distinctBy

Java 24 并没有只给接口，而是同步提供了强大内置实现：


Stream.of("hello", "java", "hi", "world")

      .gather(Gatherers.distinctBy(String::length))

      .toList(); // ["hello", "java"]

🎉 distinctBy 作为首个官方 distinct 增强，正式告别 Wrapper 时代！

✅ 2. 固定窗口分组 → windowFixed


Stream.iterate(0, n -> n + 1)

      .gather(Gatherers.windowFixed(3))

      .limit(2)

      .toList(); // [[0,1,2], [3,4,5]]

✅ 无限流支持 ✅ 无需预计算元素数 ✅ 逻辑留在流内

✅ 3. 相邻元素分析 → windowSliding(2)


readings.stream()

        .gather(Gatherers.windowSliding(2)) // [r0,r1], [r1,r2], [r2,r3]...

        .filter(w -> Math.abs(w.get(0).temp() - w.get(1).temp()) > 30)

        .toList();

🌟 真正的声明式：问题描述 = 代码结构。

🛠️ 自定义 Gatherer：像写 lambda 一样扩展 Stream

Gatherer 不是“专家专属”，Java 24 提供了极简工厂方法：


// 实现一个“遇到负数就停止”的 gatherer

Gatherer<Integer, ?, Integer> stopOnNegative = Gatherer.ofSequential(

    () -> new AtomicInteger(),                     // initializer: 状态（其实不用，占位）

    (element, _, downstream) -> {                  // integrator

        if (element < 0) return false;             // 短路！

        return downstream.push(element);            // 继续流

    },

    (_, downstream) -> downstream.flush()          // finisher

);

Stream.of(1, 2, -3, 4, 5)

      .gather(stopOnNegative)

      .toList(); // [1, 2]

🔑 核心价值：

库作者：可封装业务通用逻辑为 gather(…)，像 map 一样被复用

业务开发者：复杂流处理不再“破防”，真正实现 表达即逻辑

🧭 为什么说这是“最后一块拼图”？

| 能力 | Java 8 | Java 24 |

|------|--------|---------|

| 声明式数据流 | ✅ | ✅ |

| 并行抽象 | ✅ | ✅ |

| 终止操作可扩展 | ✅Collector） | ✅ |

| 中间操作可扩展 | ❌ | ✅Gatherer） |

至此，Stream API 终于成为一个对称、完整、可持续演进的抽象模型：

🎯 不再是“半开放体系”，而是真正属于开发者的流处理语言。

🌟 结语：我们不必再逃离 Stream

Gatherers 不是要把 Stream 变成 RxJava，

不是要取代 Reactor 或 CompletableFuture，

它解决的是一个更基础的问题：

**当 Stream 不够用时，我们终于可以——

在 Stream 的世界里，构建新的 Stream。**

这十年，我们用 Collector 勉强缝补裂痕；

今天，Java 给了我们一把锤子——

去锻造真正属于自己的流之积木。

✅ 行动建议：

升级到 Java 24（或 25 LTS）

遇到“又想写 for 循环”时，先问：这能用 Gatherer 表达吗？

库作者：考虑将高频业务逻辑封装为 gather(…) 扩展

**📌 本文完。欢迎在评论区分享：

你最想用 Gatherer 实现哪个“自定义中间操作”？

（我先来.chunkWhile(predicate) —— 按条件动态分块！）**

🔗 延伸阅读

JEP 461: Stream Gatherers（官方设计文档）
Java 24 新特性速览

Stream Gatherers：Java 24 终于补上了 Stream API 的“最后一块拼图”

十年磨一剑。自 Java 8 引入 Stream，我们写下了无数 map- filter- collect；但每当业务稍复杂一点，那句熟悉的叹息便又响起——“算了，还是 for 循环吧。”

添加微信