为什么原始Stream没有收集（收藏家）？ [英] Why don't primitive Stream have collect(Collector)?

问题描述

我正在为新手程序员编写一个库，所以我尽量保持API尽可能干净。

I'm writing a library for novice programmers so I'm trying to keep the API as clean as possible.

我的图书馆需要做的一件事在大量的int或long上执行一些复杂的计算。我的用户需要从中计算这些值所需的大量场景和业务对象，因此我认为最好的方法是使用流来允许用户将业务对象映射到 IntStream 或 LongStream 然后计算收集器内的计算。

One of the things my Library needs to do is perform some complex computations on a large collection of ints or longs. There are lots of scenarios and business objects that my users need to compute these values from, so I thought the best way would be to use streams to allow users to map business objects to IntStream or LongStream and then compute the computations inside of a collector.

但IntStream和LongStream只有3参数收集方法：

However IntStream and LongStream only have the 3 parameter collect method:

collect(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,R> combiner)

并没有简单的收集（收集器）方法 Stream< T> 有。

因此，而不是能够

Collection<T> businessObjs = ...
MyResult result = businessObjs.stream()
                              .mapToInt( ... )
                              .collect( new MyComplexComputation(...));

我必须提供这样的供应商，累加器和合并器：

I have to do provide Suppliers, accumulators and combiners like this:

MyResult result = businessObjs.stream()
                              .mapToInt( ... )
                              .collect( 
                                  ()-> new MyComplexComputationBuilder(...),
                                  (builder, v)-> builder.add(v),
                                  (a,b)-> a.merge(b))
                              .build(); //prev collect returns Builder object

对于我的新手用户来说这太复杂了，而且非常容易出错。

This is way too complicated for my novice users and is very error prone.

我的工作是使静态方法采用 IntStream 或 LongStream 作为输入并隐藏收集器的创建和执行

My work around is to make static methods that take an IntStream or LongStream as input and hide the collector creation and execution for you

public static MyResult compute(IntStream stream, ...){
       return .collect( 
                        ()-> new MyComplexComputationBuilder(...),
                        (builder, v)-> builder.add(v),
                        (a,b)-> a.merge(b))
               .build();
}

但这不符合使用Streams的常规惯例：

But that doesn't follow the normal conventions of working with Streams:

IntStream tmpStream = businessObjs.stream()
                              .mapToInt( ... );

 MyResult result = MyUtil.compute(tmpStream, ...);

因为您必须保存临时变量并将其传递给静态方法，或者创建流在静态调用中，当它与我的计算中的其他参数混合在一起时可能会引起混淆。

Because you have to either save a temp variable and pass that to the static method, or create the Stream inside the static call which may be confusing when it's is mixed in with the other parameters to my computation.

在使用<$时，是否有更简洁的方法来执行此操作c $ c> IntStream 或 LongStream ？

推荐答案

事实上我们做了一些 Collector.OfXxx 专业化的原型。我们发现 - 除了更专业类型的明显烦恼之外 - 如果没有完整的原始专用集合（如Trove，或者GS-Collections，但JDK所做的那样），这实际上并不是非常有用。没有）。例如，没有IntArrayList，Collector.OfInt只是将拳击推送到其他地方 - 从收集器到容器 - 没有大的胜利，以及更多的API表面。

We did in fact prototype some Collector.OfXxx specializations. What we found -- in addition to the obvious annoyance of more specialized types -- was that this was not really very useful without having a full complement of primitive-specialized collections (like Trove does, or GS-Collections, but which the JDK does not have). Without an IntArrayList, for example, a Collector.OfInt merely pushes the boxing somewhere else -- from the Collector to the container -- which no big win, and lots more API surface.

这篇关于为什么原始Stream没有收集（收藏家）？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！