我一直在浏览最新的 LTE Java 17 版本的新闻和源代码，并且遇到了名为mapMulti. 早期访问JavaDoc说它类似于flatMap.
<R> Stream<R> mapMulti(BiConsumer<? super T,? super Consumer<R>> mapper)
- 如何使用此方法执行 1 到 0..n 映射？
- 新方法如何工作以及它与
flatMap. 每个人什么时候更可取？ mapper可以调用多少次？
问问题
1426 次
2 回答
35
Stream::mapMulti是一种被归类为中间操作的新方法。
它需要一个BiConsumer<T, Consumer<R>> mapper即将被处理的元素Consumer。后者使该方法乍一看很奇怪，因为它不同于我们在其他中间方法（例如map, ）中所使用的方法filter，或者peek它们都没有使用 的任何变体*Consumer。
ConsumerAPI 本身在 lambda 表达式中提供的权限的目的是接受任何数量的元素以在后续管道中可用。因此，所有元素，无论有多少，都将被传播。
使用简单的片段进行解释
一对多 (0..1) 映射（类似于
filter）consumer.accept(R r)仅对少数选定项目使用可实现类似过滤器的管道。如果根据谓词检查元素并且它映射到不同的值，这可能会很有用，否则这将使用filterand的组合map来完成。以下Stream.of("Java", "Python", "JavaScript", "C#", "Ruby") .mapMulti((str, consumer) -> { if (str.length() > 4) { consumer.accept(str.length()); // lengths larger than 4 } }) .forEach(i -> System.out.print(i + " ")); // 6 10一对一映射（类似于
map）使用前面的示例，当省略条件并且每个元素都映射到新元素并使用 接受时
consumer，该方法的行为实际上类似于map：Stream.of("Java", "Python", "JavaScript", "C#", "Ruby") .mapMulti((str, consumer) -> consumer.accept(str.length())) .forEach(i -> System.out.print(i + " ")); // 4 6 10 2 4一对多映射（类似于
flatMap）这里的事情变得有趣了，因为一个人可以调用
consumer.accept(R r)任意次数。假设我们要复制代表字符串长度的数字本身，即2变为2,2。4变成4,4,4,4. 变得0一无所有。Stream.of("Java", "Python", "JavaScript", "C#", "Ruby", "") .mapMulti((str, consumer) -> { for (int i = 0; i < str.length(); i++) { consumer.accept(str.length()); } }) .forEach(i -> System.out.print(i + " ")); // 4 4 4 4 6 6 6 6 6 6 10 10 10 10 10 10 10 10 10 10 2 2 4 4 4 4
与 flatMap 的比较
这种机制的真正想法是可以多次调用（包括零次），并且它在SpinedBuffer内部的使用允许将元素推送到单个扁平 Stream 实例中，而无需为每组输出元素创建一个新实例，而不像flatMap. JavaDoc说明了使用此方法优于使用此方法的两个用flatMap例：
- 当用少量（可能为零）的元素替换每个流元素时。使用这种方法可以避免为每组结果元素创建一个新的 Stream 实例的开销，正如 flatMap 所要求的那样。
- 当使用命令式方法生成结果元素比以 Stream 的形式返回结果元素更容易时。
在性能方面，新方法mapMulti在这种情况下是赢家。查看此答案底部的基准。
过滤地图场景
使用此方法代替filter或map单独使用这种方法没有意义，因为它很冗长，而且无论如何都会创建一个中间流。例外情况可能是替换了一起调用.filter(..).map(..)的链，这在检查元素类型及其转换等情况下很方便。
int sum = Stream.of(1, 2.0, 3.0, 4F, 5, 6L)
.mapMultiToInt((number, consumer) -> {
if (number instanceof Integer) {
consumer.accept((Integer) number);
}
})
.sum();
// 6
int sum = Stream.of(1, 2.0, 3.0, 4F, 5, 6L)
.filter(number -> number instanceof Integer)
.mapToInt(number -> (Integer) number)
.sum();
如上所示，引入了它的变体mapMultiToDouble，如mapMultiToInt和mapMultiToLong。这伴随mapMulti着原始流中的方法，例如IntStream mapMulti(IntStream.IntMapMultiConsumer mapper). 此外，还引入了三个新的功能接口。基本上，它们是 的原始变体BiConsumer<T, Consumer<R>>，例如：
@FunctionalInterface
interface IntMapMultiConsumer {
void accept(int value, IntConsumer ic);
}
结合真实用例场景
这种方法的真正强大之处在于其使用的灵活性，并且一次只创建一个 Stream，这是优于flatMap. 下面的两个片段代表了一个平面映射Product及其List<Variation>到0..n由Offer类表示的报价并基于某些条件（产品类别和变体可用性）。
Product与String name,和.int basePrice_String categoryList<Variation> variationsVariation与String name,int price和boolean availability.
List<Product> products = ...
List<Offer> offers = products.stream()
.mapMulti((product, consumer) -> {
if ("PRODUCT_CATEGORY".equals(product.getCategory())) {
for (Variation v : product.getVariations()) {
if (v.isAvailable()) {
Offer offer = new Offer(
product.getName() + "_" + v.getName(),
product.getBasePrice() + v.getPrice());
consumer.accept(offer);
}
}
}
})
.collect(Collectors.toList());
List<Product> products = ...
List<Offer> offers = products.stream()
.filter(product -> "PRODUCT_CATEGORY".equals(product.getCategory()))
.flatMap(product -> product.getVariations().stream()
.filter(Variation::isAvailable)
.map(v -> new Offer(
product.getName() + "_" + v.getName(),
product.getBasePrice() + v.getPrice()
))
)
.collect(Collectors.toList());
mapMulti与在后一个片段中看到的使用flatMap,map和filter. 从这个角度来看，使用命令式方法是否更容易取决于用例。递归是JavaDoc中描述的一个很好的例子。
基准
正如所承诺的，我已经根据从评论中收集的想法编写了一堆微基准。只要有相当多的代码要发布，我就创建了一个包含实现细节的GitHub 存储库，我将只分享结果。
Stream::flatMap(Function)与Stream::mapMulti(BiConsumer) 源
在这里，我们可以看到巨大的差异，并证明了较新的方法实际上按照描述的方式工作，并且它的使用避免了为每个处理的元素创建一个新的 Stream 实例的开销。
Benchmark Mode Cnt Score Error Units
MapMulti_FlatMap.flatMap avgt 25 73.852 ± 3.433 ns/op
MapMulti_FlatMap.mapMulti avgt 25 17.495 ± 0.476 ns/op
Stream::filter(Predicate).map(Function)与Stream::mapMulti(BiConsumer) 源
使用链式管道（虽然不是嵌套的）很好。
Benchmark Mode Cnt Score Error Units
MapMulti_FilterMap.filterMap avgt 25 7.973 ± 0.378 ns/op
MapMulti_FilterMap.mapMulti avgt 25 7.765 ± 0.633 ns/op
Stream::flatMap(Function)与Optional::stream()Stream::mapMulti(BiConsumer) 源_
这个非常有趣，尤其是在使用方面（参见源代码）：我们现在可以使用扁平化，mapMulti(Optional::ifPresent)并且正如预期的那样，在这种情况下，新方法要快一些。
Benchmark Mode Cnt Score Error Units
MapMulti_FlatMap_Optional.flatMap avgt 25 20.186 ± 1.305 ns/op
MapMulti_FlatMap_Optional.mapMulti avgt 25 10.498 ± 0.403 ns/op
于 2020-09-30T07:27:02.207 回答
11
解决方案
当使用命令式方法生成结果元素比以 Stream 的形式返回结果元素更容易时。
我们可以看到它现在有一个有限的 yield 语句 C#变体。限制是我们总是需要来自流的初始输入，因为这是一个中间操作，此外，我们在一个函数评估中推动的元素没有短路。
尽管如此，它还是带来了有趣的机会。
例如，以前实现斐波那契数流需要使用能够保存两个值的临时对象的解决方案。
现在，我们可以使用类似的东西：
IntStream.of(0)
.mapMulti((a,c) -> {
for(int b = 1; a >=0; b = a + (a = b))
c.accept(a);
})
/* additional stream operations here */
.forEach(System.out::println);
如上所述，当值溢出时它会停止，int当我们使用不消耗所有值的终端操作时它不会短路，但是，这个产生然后被忽略的值的循环可能仍然比其他方法更快。
受此答案启发的另一个示例，从根到最具体的类层次结构迭代：
Stream.of(LinkedHashMap.class).mapMulti(MapMultiExamples::hierarchy)
/* additional stream operations here */
.forEach(System.out::println);
}
static void hierarchy(Class<?> cl, Consumer<? super Class<?>> co) {
if(cl != null) {
hierarchy(cl.getSuperclass(), co);
co.accept(cl);
}
}
与旧方法不同，它不需要额外的堆存储并且可能运行得更快（假设合理的类深度不会使递归适得其反）。
还有这样的怪物
List<A> list = IntStream.range(0, r_i).boxed() .flatMap(i -> IntStream.range(0, r_j).boxed() .flatMap(j -> IntStream.range(0, r_k) .mapToObj(k -> new A(i, j, k)))) .collect(Collectors.toList());
现在可以写成
List<A> list = IntStream.range(0, r_i).boxed()
.<A>mapMulti((i,c) -> {
for(int j = 0; j < r_j; j++) {
for(int k = 0; k < r_k; k++) {
c.accept(new A(i, j, k));
}
}
})
.collect(Collectors.toList());
与嵌套flatMap步骤相比，它失去了一些并行机会，参考实现无论如何都没有利用这些机会。对于像上面这样的非短路操作，新方法可能会受益于减少装箱和减少捕获 lambda 表达式的实例化。但是当然，应该明智地使用它，而不是将每个构造都重写为命令式版本（在很多人试图将每个命令式代码重写为函数式版本之后）......</p>
于 2020-09-30T17:14:39.027 回答