Interface DoubleCollector<A,R>

 Type Parameters:
A
 the mutable accumulation type of the reduction operation (often hidden as an implementation detail)R
 the result type of the reduction operation
public interface DoubleCollector<A,R>
ACollector
specialized to work with primitivedouble
. Since:
 0.3.0
 Author:
 Tagir Valeev
 See Also:
DoubleStreamEx.collect(DoubleCollector)


Nested Class Summary

Nested classes/interfaces inherited from interface Collector
Collector.Characteristics


Method Summary
All Methods Static Methods Instance Methods Abstract Methods Default Methods Modifier and Type Method Description default BiConsumer<A,Double>
accumulator()
A function that folds a value into a mutable result container.default <RR> DoubleCollector<A,RR>
andThen(Function<R,RR> finisher)
Adapts this collector to perform an additional finishing transformation.static DoubleCollector<?,OptionalDouble>
averaging()
Returns aDoubleCollector
that produces the arithmetic mean of the input elements or an empty optional if no elements are collected.default BinaryOperator<A>
combiner()
A function that accepts two partial results and combines them returning either existing partial result or new one.static DoubleCollector<?,Long>
counting()
Returns aDoubleCollector
that counts the number of input elements and returns the result asLong
.static DoubleCollector<?,Integer>
countingInt()
Returns anDoubleCollector
that counts the number of input elements and returns the result asInteger
.ObjDoubleConsumer<A>
doubleAccumulator()
A function that folds a value into a mutable result container.static <K> DoubleCollector<?,Map<K,double[]>>
groupingBy(DoubleFunction<? extends K> classifier)
Returns aDoubleCollector
implementing a "group by" operation on input numbers, grouping them according to a classification function, and returning the results in aMap
.static <K,D,A,M extends Map<K,D>>
DoubleCollector<?,M>groupingBy(DoubleFunction<? extends K> classifier, Supplier<M> mapFactory, DoubleCollector<A,D> downstream)
Returns aDoubleCollector
implementing a cascaded "group by" operation on input numbers, grouping them according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstreamIntCollector
.static <K,D,A>
DoubleCollector<?,Map<K,D>>groupingBy(DoubleFunction<? extends K> classifier, DoubleCollector<A,D> downstream)
Returns aDoubleCollector
implementing a cascaded "group by" operation on input numbers, grouping them according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstreamIntCollector
.static DoubleCollector<?,String>
joining(CharSequence delimiter)
Returns aDoubleCollector
that converts the input numbers to strings and concatenates them, separated by the specified delimiter, in encounter order.static DoubleCollector<?,String>
joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
Returns aDoubleCollector
that converts the input numbers to strings and concatenates them, separated by the specified delimiter, with the specified prefix and suffix, in encounter order.static <A,R>
DoubleCollector<?,R>mapping(DoubleUnaryOperator mapper, DoubleCollector<A,R> downstream)
Adapts aDoubleCollector
to another one by applying a mapping function to each input element before accumulation.static <U,A,R>
DoubleCollector<?,R>mappingToObj(DoubleFunction<U> mapper, Collector<U,A,R> downstream)
Adapts aCollector
accepting elements of typeU
to aDoubleCollector
by applying a mapping function to each input element before accumulation.static DoubleCollector<?,OptionalDouble>
max()
Returns aDoubleCollector
that produces the maximal element, described as anOptionalDouble
.BiConsumer<A,A>
merger()
A function that merges the second partial result into the first partial result.static DoubleCollector<?,OptionalDouble>
min()
Returns aDoubleCollector
that produces the minimal element, described as anOptionalDouble
.static <A,R>
DoubleCollector<A,R>of(Supplier<A> supplier, ObjDoubleConsumer<A> doubleAccumulator, BiConsumer<A,A> merger, Function<A,R> finisher)
Returns a newDoubleCollector
described by the givensupplier
,accumulator
,merger
, andfinisher
functions.static <R> DoubleCollector<R,R>
of(Supplier<R> supplier, ObjDoubleConsumer<R> doubleAccumulator, BiConsumer<R,R> merger)
Returns a newDoubleCollector
described by the givensupplier
,accumulator
, andmerger
functions.static <A,R>
DoubleCollector<?,R>of(Collector<Double,A,R> collector)
Adapts aCollector
which accepts elements of typeDouble
to aDoubleCollector
.static DoubleCollector<?,Map<Boolean,double[]>>
partitioningBy(DoublePredicate predicate)
Returns aDoubleCollector
which partitions the input elements according to aDoublePredicate
, and organizes them into aMap<Boolean, double[]>
.static <A,D>
DoubleCollector<?,Map<Boolean,D>>partitioningBy(DoublePredicate predicate, DoubleCollector<A,D> downstream)
Returns aDoubleCollector
which partitions the input numbers according to aDoublePredicate
, reduces the values in each partition according to anotherIntCollector
, and organizes them into aMap<Boolean, D>
whose values are the result of the downstream reduction.static DoubleCollector<?,Double>
reducing(double identity, DoubleBinaryOperator op)
Returns aDoubleCollector
which performs a reduction of its input numbers under a specifiedIntBinaryOperator
using the provided identity.static DoubleCollector<?,OptionalDouble>
reducing(DoubleBinaryOperator op)
Returns aDoubleCollector
which performs a reduction of its input numbers under a specifiedDoubleBinaryOperator
.static DoubleCollector<?,DoubleSummaryStatistics>
summarizing()
Returns aDoubleCollector
which returns summary statistics for the input elements.static DoubleCollector<?,Double>
summing()
Returns aDoubleCollector
that produces the sum of the input elements.static DoubleCollector<?,double[]>
toArray()
Returns aDoubleCollector
that produces the array of the input elements.static DoubleCollector<?,boolean[]>
toBooleanArray(DoublePredicate predicate)
Returns aDoubleCollector
which produces a boolean array containing the results of applying the given predicate to the input elements, in encounter order.static DoubleCollector<?,float[]>
toFloatArray()
Returns aDoubleCollector
that produces thefloat[]
array of the input elements converting them via(float)
casting.
Methods inherited from interface Collector
characteristics, finisher, supplier




Method Detail

doubleAccumulator
ObjDoubleConsumer<A> doubleAccumulator()
A function that folds a value into a mutable result container. Returns:
 a function which folds a value into a mutable result container

accumulator
default BiConsumer<A,Double> accumulator()
A function that folds a value into a mutable result container. The default implementation callsdoubleAccumulator()
on unboxed value. Specified by:
accumulator
in interfaceCollector<Double,A,R>
 Returns:
 a function which folds a value into a mutable result container

andThen
default <RR> DoubleCollector<A,RR> andThen(Function<R,RR> finisher)
Adapts this collector to perform an additional finishing transformation. Type Parameters:
RR
 result type of the resulting collector Parameters:
finisher
 a function to be applied to the final result of this collector Returns:
 a collector which performs the action of this collector, followed by an additional finishing step
 Since:
 0.3.7

of
static <R> DoubleCollector<R,R> of(Supplier<R> supplier, ObjDoubleConsumer<R> doubleAccumulator, BiConsumer<R,R> merger)
Returns a newDoubleCollector
described by the givensupplier
,accumulator
, andmerger
functions. The resultingDoubleCollector
has theCollector.Characteristics.IDENTITY_FINISH
characteristic. Type Parameters:
R
 The type of intermediate accumulation result, and final result, for the new collector Parameters:
supplier
 The supplier function for the new collectordoubleAccumulator
 The doubleAccumulator function for the new collectormerger
 The merger function for the new collector Returns:
 the new
DoubleCollector

of
static <A,R> DoubleCollector<?,R> of(Collector<Double,A,R> collector)
Adapts aCollector
which accepts elements of typeDouble
to aDoubleCollector
. Type Parameters:
A
 The intermediate accumulation type of the collectorR
 The final result type of the collector Parameters:
collector
 aCollector
to adapt Returns:
 a
DoubleCollector
which behaves in the same way as input collector.

of
static <A,R> DoubleCollector<A,R> of(Supplier<A> supplier, ObjDoubleConsumer<A> doubleAccumulator, BiConsumer<A,A> merger, Function<A,R> finisher)
Returns a newDoubleCollector
described by the givensupplier
,accumulator
,merger
, andfinisher
functions. Type Parameters:
A
 The intermediate accumulation type of the new collectorR
 The final result type of the new collector Parameters:
supplier
 The supplier function for the new collectordoubleAccumulator
 The doubleAccumulator function for the new collectormerger
 The merger function for the new collectorfinisher
 The finisher function for the new collector Returns:
 the new
DoubleCollector

joining
static DoubleCollector<?,String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
Returns aDoubleCollector
that converts the input numbers to strings and concatenates them, separated by the specified delimiter, with the specified prefix and suffix, in encounter order. Parameters:
delimiter
 the delimiter to be used between each elementprefix
 the sequence of characters to be used at the beginning of the joined resultsuffix
 the sequence of characters to be used at the end of the joined result Returns:
 A
DoubleCollector
which concatenates the input numbers, separated by the specified delimiter, in encounter order

joining
static DoubleCollector<?,String> joining(CharSequence delimiter)
Returns aDoubleCollector
that converts the input numbers to strings and concatenates them, separated by the specified delimiter, in encounter order. Parameters:
delimiter
 the delimiter to be used between each element Returns:
 A
DoubleCollector
which concatenates the input numbers, separated by the specified delimiter, in encounter order

counting
static DoubleCollector<?,Long> counting()
Returns aDoubleCollector
that counts the number of input elements and returns the result asLong
. If no elements are present, the result is 0. Returns:
 a
DoubleCollector
that counts the input elements

countingInt
static DoubleCollector<?,Integer> countingInt()
Returns anDoubleCollector
that counts the number of input elements and returns the result asInteger
. If no elements are present, the result is 0. Returns:
 an
DoubleCollector
that counts the input elements

summing
static DoubleCollector<?,Double> summing()
Returns aDoubleCollector
that produces the sum of the input elements. If no elements are present, the result is 0.0. Returns:
 a
DoubleCollector
that produces the sum of the input elements

averaging
static DoubleCollector<?,OptionalDouble> averaging()
Returns aDoubleCollector
that produces the arithmetic mean of the input elements or an empty optional if no elements are collected. Returns:
 a
DoubleCollector
that produces the arithmetic mean of the input elements  Since:
 0.3.7

min
static DoubleCollector<?,OptionalDouble> min()
Returns aDoubleCollector
that produces the minimal element, described as anOptionalDouble
. If no elements are present, the result is an emptyOptionalDouble
. Returns:
 a
DoubleCollector
that produces the minimal element.

max
static DoubleCollector<?,OptionalDouble> max()
Returns aDoubleCollector
that produces the maximal element, described as anOptionalDouble
. If no elements are present, the result is an emptyOptionalDouble
. Returns:
 a
DoubleCollector
that produces the maximal element.

mapping
static <A,R> DoubleCollector<?,R> mapping(DoubleUnaryOperator mapper, DoubleCollector<A,R> downstream)
Adapts aDoubleCollector
to another one by applying a mapping function to each input element before accumulation. Type Parameters:
A
 intermediate accumulation type of the downstream collectorR
 result type of collector Parameters:
mapper
 a function to be applied to the input elementsdownstream
 a collector which will accept mapped values Returns:
 a collector which applies the mapping function to the input elements and provides the mapped results to the downstream collector

mappingToObj
static <U,A,R> DoubleCollector<?,R> mappingToObj(DoubleFunction<U> mapper, Collector<U,A,R> downstream)
Adapts aCollector
accepting elements of typeU
to aDoubleCollector
by applying a mapping function to each input element before accumulation. Type Parameters:
U
 type of elements accepted by downstream collectorA
 intermediate accumulation type of the downstream collectorR
 result type of collector Parameters:
mapper
 a function to be applied to the input elementsdownstream
 a collector which will accept mapped values Returns:
 a collector which applies the mapping function to the input elements and provides the mapped results to the downstream collector

reducing
static DoubleCollector<?,OptionalDouble> reducing(DoubleBinaryOperator op)
Returns aDoubleCollector
which performs a reduction of its input numbers under a specifiedDoubleBinaryOperator
. The result is described as anOptionalDouble
. Parameters:
op
 aDoubleBinaryOperator
used to reduce the input numbers Returns:
 a
DoubleCollector
which implements the reduction operation.

reducing
static DoubleCollector<?,Double> reducing(double identity, DoubleBinaryOperator op)
Returns aDoubleCollector
which performs a reduction of its input numbers under a specifiedIntBinaryOperator
using the provided identity. Parameters:
identity
 the identity value for the reduction (also, the value that is returned when there are no input elements)op
 aDoubleBinaryOperator
used to reduce the input numbers Returns:
 a
DoubleCollector
which implements the reduction operation

summarizing
static DoubleCollector<?,DoubleSummaryStatistics> summarizing()
Returns aDoubleCollector
which returns summary statistics for the input elements. Returns:
 a
DoubleCollector
implementing the summarystatistics reduction

partitioningBy
static DoubleCollector<?,Map<Boolean,double[]>> partitioningBy(DoublePredicate predicate)
Returns aDoubleCollector
which partitions the input elements according to aDoublePredicate
, and organizes them into aMap<Boolean, double[]>
. There are no guarantees on the type, mutability, serializability, or threadsafety of theMap
returned. Parameters:
predicate
 a predicate used for classifying input elements Returns:
 a
DoubleCollector
implementing the partitioning operation

partitioningBy
static <A,D> DoubleCollector<?,Map<Boolean,D>> partitioningBy(DoublePredicate predicate, DoubleCollector<A,D> downstream)
Returns aDoubleCollector
which partitions the input numbers according to aDoublePredicate
, reduces the values in each partition according to anotherIntCollector
, and organizes them into aMap<Boolean, D>
whose values are the result of the downstream reduction.There are no guarantees on the type, mutability, serializability, or threadsafety of the
Map
returned. Type Parameters:
A
 the intermediate accumulation type of the downstream collectorD
 the result type of the downstream reduction Parameters:
predicate
 a predicate used for classifying input elementsdownstream
 aDoubleCollector
implementing the downstream reduction Returns:
 a
DoubleCollector
implementing the cascaded partitioning operation

groupingBy
static <K> DoubleCollector<?,Map<K,double[]>> groupingBy(DoubleFunction<? extends K> classifier)
Returns aDoubleCollector
implementing a "group by" operation on input numbers, grouping them according to a classification function, and returning the results in aMap
.The classification function maps elements to some key type
K
. The collector produces aMap<K, double[]>
whose keys are the values resulting from applying the classification function to the input numbers, and whose corresponding values are arrays containing the input numbers which map to the associated key under the classification function.There are no guarantees on the type, mutability, serializability, or threadsafety of the
Map
objects returned. Type Parameters:
K
 the type of the keys Parameters:
classifier
 the classifier function mapping input elements to keys Returns:
 a
DoubleCollector
implementing the groupby operation

groupingBy
static <K,D,A> DoubleCollector<?,Map<K,D>> groupingBy(DoubleFunction<? extends K> classifier, DoubleCollector<A,D> downstream)
Returns aDoubleCollector
implementing a cascaded "group by" operation on input numbers, grouping them according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstreamIntCollector
.The classification function maps elements to some key type
K
. The downstream collector produces a result of typeD
. The resulting collector produces aMap<K, D>
.There are no guarantees on the type, mutability, serializability, or threadsafety of the
Map
returned. Type Parameters:
K
 the type of the keysA
 the intermediate accumulation type of the downstream collectorD
 the result type of the downstream reduction Parameters:
classifier
 a classifier function mapping input elements to keysdownstream
 aDoubleCollector
implementing the downstream reduction Returns:
 a
DoubleCollector
implementing the cascaded groupby operation

groupingBy
static <K,D,A,M extends Map<K,D>> DoubleCollector<?,M> groupingBy(DoubleFunction<? extends K> classifier, Supplier<M> mapFactory, DoubleCollector<A,D> downstream)
Returns aDoubleCollector
implementing a cascaded "group by" operation on input numbers, grouping them according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstreamIntCollector
. TheMap
produced by the Collector is created with the supplied factory function.The classification function maps elements to some key type
K
. The downstream collector produces a result of typeD
. The resulting collector produces aMap<K, D>
. Type Parameters:
K
 the type of the keysA
 the intermediate accumulation type of the downstream collectorD
 the result type of the downstream reductionM
 the type of the resultingMap
 Parameters:
classifier
 a classifier function mapping input elements to keysdownstream
 aDoubleCollector
implementing the downstream reductionmapFactory
 a function which, when called, produces a new emptyMap
of the desired type Returns:
 a
DoubleCollector
implementing the cascaded groupby operation

toArray
static DoubleCollector<?,double[]> toArray()
Returns aDoubleCollector
that produces the array of the input elements. If no elements are present, the result is an empty array. Returns:
 a
DoubleCollector
that produces the array of the input elements

toFloatArray
static DoubleCollector<?,float[]> toFloatArray()
Returns aDoubleCollector
that produces thefloat[]
array of the input elements converting them via(float)
casting. If no elements are present, the result is an empty array. Returns:
 a
DoubleCollector
that produces thefloat[]
array of the input elements

toBooleanArray
static DoubleCollector<?,boolean[]> toBooleanArray(DoublePredicate predicate)
Returns aDoubleCollector
which produces a boolean array containing the results of applying the given predicate to the input elements, in encounter order. Parameters:
predicate
 a noninterfering, stateless predicate to apply to each input element. The result values of this predicate are collected to the resulting boolean array. Returns:
 a
DoubleCollector
which collects the results of the predicate function to the boolean array, in encounter order.  Since:
 0.3.8

merger
BiConsumer<A,A> merger()
A function that merges the second partial result into the first partial result. Returns:
 a function that merges the second partial result into the first partial result.

combiner
default BinaryOperator<A> combiner()
A function that accepts two partial results and combines them returning either existing partial result or new one. The default implementation calls themerger()
and returns the first partial result.

