Package | Description |
---|---|
java.util.stream |
Classes to support functional-style operations on streams of elements, such
as map-reduce transformations on collections.
|
Modifier and Type | Method | Description |
---|---|---|
static <T> Collector<T,?,Double> |
Collectors.averagingDouble(ToDoubleFunction<? super T> mapper) |
Returns a
Collector that produces the arithmetic mean of a double-valued
function applied to the input elements. |
static <T> Collector<T,?,Double> |
Collectors.averagingInt(ToIntFunction<? super T> mapper) |
Returns a
Collector that produces the arithmetic mean of an integer-valued
function applied to the input elements. |
static <T> Collector<T,?,Double> |
Collectors.averagingLong(ToLongFunction<? super T> mapper) |
Returns a
Collector that produces the arithmetic mean of a long-valued
function applied to the input elements. |
static <T,A,R,RR> Collector<T,A,RR> |
Collectors.collectingAndThen(Collector<T,A,R> downstream,
Function<R,RR> finisher) |
Adapts a
Collector to perform an additional finishing
transformation. |
static <T> Collector<T,?,Long> |
Collectors.counting() |
Returns a
Collector accepting elements of type T that
counts the number of input elements. |
static <T,A,R> Collector<T,?,R> |
Collectors.filtering(Predicate<? super T> predicate,
Collector<? super T,A,R> downstream) |
Adapts a
Collector to one accepting elements of the same type
T by applying the predicate to each input element and only
accumulating if the predicate returns true . |
static <T,U,A,R> Collector<T,?,R> |
Collectors.flatMapping(Function<? super T,? extends Stream<? extends U>> mapper,
Collector<? super U,A,R> downstream) |
Adapts a
Collector accepting elements of type U to one
accepting elements of type T by applying a flat mapping function
to each input element before accumulation. |
static <T,K> Collector<T,?,Map<K,List<T>>> |
Collectors.groupingBy(Function<? super T,? extends K> classifier) |
Returns a
Collector implementing a "group by" operation on
input elements of type T , grouping elements according to a
classification function, and returning the results in a Map . |
static <T,K,D,A,M extends Map<K,D>> |
Collectors.groupingBy(Function<? super T,? extends K> classifier,
Supplier<M> mapFactory,
Collector<? super T,A,D> downstream) |
Returns a
Collector implementing a cascaded "group by" operation
on input elements of type T , grouping elements according to a
classification function, and then performing a reduction operation on
the values associated with a given key using the specified downstream
Collector . |
static <T,K,A,D> Collector<T,?,Map<K,D>> |
Collectors.groupingBy(Function<? super T,? extends K> classifier,
Collector<? super T,A,D> downstream) |
Returns a
Collector implementing a cascaded "group by" operation
on input elements of type T , grouping elements according to a
classification function, and then performing a reduction operation on
the values associated with a given key using the specified downstream
Collector . |
static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>> |
Collectors.groupingByConcurrent(Function<? super T,? extends K> classifier) |
Returns a concurrent
Collector implementing a "group by"
operation on input elements of type T , grouping elements
according to a classification function. |
static <T,K,A,D,M extends ConcurrentMap<K,D>> |
Collectors.groupingByConcurrent(Function<? super T,? extends K> classifier,
Supplier<M> mapFactory,
Collector<? super T,A,D> downstream) |
Returns a concurrent
Collector implementing a cascaded "group by"
operation on input elements of type T , grouping elements
according to a classification function, and then performing a reduction
operation on the values associated with a given key using the specified
downstream Collector . |
static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>> |
Collectors.groupingByConcurrent(Function<? super T,? extends K> classifier,
Collector<? super T,A,D> downstream) |
Returns a concurrent
Collector implementing a cascaded "group by"
operation on input elements of type T , grouping elements
according to a classification function, and then performing a reduction
operation on the values associated with a given key using the specified
downstream Collector . |
static Collector<CharSequence,?,String> |
Collectors.joining() |
Returns a
Collector that concatenates the input elements into a
String , in encounter order. |
static Collector<CharSequence,?,String> |
Collectors.joining(CharSequence delimiter) |
Returns a
Collector that concatenates the input elements,
separated by the specified delimiter, in encounter order. |
static Collector<CharSequence,?,String> |
Collectors.joining(CharSequence delimiter,
CharSequence prefix,
CharSequence suffix) |
Returns a
Collector that concatenates the input elements,
separated by the specified delimiter, with the specified prefix and
suffix, in encounter order. |
static <T,U,A,R> Collector<T,?,R> |
Collectors.mapping(Function<? super T,? extends U> mapper,
Collector<? super U,A,R> downstream) |
Adapts a
Collector accepting elements of type U to one
accepting elements of type T by applying a mapping function to
each input element before accumulation. |
static <T> Collector<T,?,Optional<T>> |
Collectors.maxBy(Comparator<? super T> comparator) |
Returns a
Collector that produces the maximal element according
to a given Comparator , described as an Optional<T> . |
static <T> Collector<T,?,Optional<T>> |
Collectors.minBy(Comparator<? super T> comparator) |
Returns a
Collector that produces the minimal element according
to a given Comparator , described as an Optional<T> . |
static <T,A,R> Collector<T,A,R> |
Collector.of(Supplier<A> supplier,
BiConsumer<A,T> accumulator,
BinaryOperator<A> combiner,
Function<A,R> finisher,
Collector.Characteristics... characteristics) |
Returns a new
Collector described by the given supplier ,
accumulator , combiner , and finisher functions. |
static <T,R> Collector<T,R,R> |
Collector.of(Supplier<R> supplier,
BiConsumer<R,T> accumulator,
BinaryOperator<R> combiner,
Collector.Characteristics... characteristics) |
Returns a new
Collector described by the given supplier ,
accumulator , and combiner functions. |
static <T> Collector<T,?,Map<Boolean,List<T>>> |
Collectors.partitioningBy(Predicate<? super T> predicate) |
Returns a
Collector which partitions the input elements according
to a Predicate , and organizes them into a
Map<Boolean, List<T>> . |
static <T,D,A> Collector<T,?,Map<Boolean,D>> |
Collectors.partitioningBy(Predicate<? super T> predicate,
Collector<? super T,A,D> downstream) |
Returns a
Collector which partitions the input elements according
to a Predicate , reduces the values in each partition according to
another Collector , and organizes them into a
Map<Boolean, D> whose values are the result of the downstream
reduction. |
static <T> Collector<T,?,Optional<T>> |
Collectors.reducing(BinaryOperator<T> op) |
Returns a
Collector which performs a reduction of its
input elements under a specified BinaryOperator . |
static <T> Collector<T,?,T> |
Collectors.reducing(T identity,
BinaryOperator<T> op) |
Returns a
Collector which performs a reduction of its
input elements under a specified BinaryOperator using the
provided identity. |
static <T,U> Collector<T,?,U> |
Collectors.reducing(U identity,
Function<? super T,? extends U> mapper,
BinaryOperator<U> op) |
Returns a
Collector which performs a reduction of its
input elements under a specified mapping function and
BinaryOperator . |
static <T> Collector<T,?,DoubleSummaryStatistics> |
Collectors.summarizingDouble(ToDoubleFunction<? super T> mapper) |
Returns a
Collector which applies an double -producing
mapping function to each input element, and returns summary statistics
for the resulting values. |
static <T> Collector<T,?,IntSummaryStatistics> |
Collectors.summarizingInt(ToIntFunction<? super T> mapper) |
Returns a
Collector which applies an int -producing
mapping function to each input element, and returns summary statistics
for the resulting values. |
static <T> Collector<T,?,LongSummaryStatistics> |
Collectors.summarizingLong(ToLongFunction<? super T> mapper) |
Returns a
Collector which applies an long -producing
mapping function to each input element, and returns summary statistics
for the resulting values. |
static <T> Collector<T,?,Double> |
Collectors.summingDouble(ToDoubleFunction<? super T> mapper) |
Returns a
Collector that produces the sum of a double-valued
function applied to the input elements. |
static <T> Collector<T,?,Integer> |
Collectors.summingInt(ToIntFunction<? super T> mapper) |
Returns a
Collector that produces the sum of a integer-valued
function applied to the input elements. |
static <T> Collector<T,?,Long> |
Collectors.summingLong(ToLongFunction<? super T> mapper) |
Returns a
Collector that produces the sum of a long-valued
function applied to the input elements. |
static <T,C extends Collection<T>> |
Collectors.toCollection(Supplier<C> collectionFactory) |
Returns a
Collector that accumulates the input elements into a
new Collection , in encounter order. |
static <T,K,U> Collector<T,?,ConcurrentMap<K,U>> |
Collectors.toConcurrentMap(Function<? super T,? extends K> keyMapper,
Function<? super T,? extends U> valueMapper) |
Returns a concurrent
Collector that accumulates elements into a
ConcurrentMap whose keys and values are the result of applying
the provided mapping functions to the input elements. |
static <T,K,U> Collector<T,?,ConcurrentMap<K,U>> |
Collectors.toConcurrentMap(Function<? super T,? extends K> keyMapper,
Function<? super T,? extends U> valueMapper,
BinaryOperator<U> mergeFunction) |
Returns a concurrent
Collector that accumulates elements into a
ConcurrentMap whose keys and values are the result of applying
the provided mapping functions to the input elements. |
static <T,K,U,M extends ConcurrentMap<K,U>> |
Collectors.toConcurrentMap(Function<? super T,? extends K> keyMapper,
Function<? super T,? extends U> valueMapper,
BinaryOperator<U> mergeFunction,
Supplier<M> mapFactory) |
Returns a concurrent
Collector that accumulates elements into a
ConcurrentMap whose keys and values are the result of applying
the provided mapping functions to the input elements. |
static <T> Collector<T,?,List<T>> |
Collectors.toList() |
Returns a
Collector that accumulates the input elements into a
new List . |
static <T,K,U> Collector<T,?,Map<K,U>> |
Collectors.toMap(Function<? super T,? extends K> keyMapper,
Function<? super T,? extends U> valueMapper) |
Returns a
Collector that accumulates elements into a
Map whose keys and values are the result of applying the provided
mapping functions to the input elements. |
static <T,K,U> Collector<T,?,Map<K,U>> |
Collectors.toMap(Function<? super T,? extends K> keyMapper,
Function<? super T,? extends U> valueMapper,
BinaryOperator<U> mergeFunction) |
Returns a
Collector that accumulates elements into a
Map whose keys and values are the result of applying the provided
mapping functions to the input elements. |
static <T,K,U,M extends Map<K,U>> |
Collectors.toMap(Function<? super T,? extends K> keyMapper,
Function<? super T,? extends U> valueMapper,
BinaryOperator<U> mergeFunction,
Supplier<M> mapFactory) |
Returns a
Collector that accumulates elements into a
Map whose keys and values are the result of applying the provided
mapping functions to the input elements. |
static <T> Collector<T,?,Set<T>> |
Collectors.toSet() |
Returns a
Collector that accumulates the input elements into a
new Set . |
Modifier and Type | Method | Description |
---|---|---|
<R,A> R |
Stream.collect(Collector<? super T,A,R> collector) |
Performs a mutable
reduction operation on the elements of this stream using a
Collector . |
static <T,A,R,RR> Collector<T,A,RR> |
Collectors.collectingAndThen(Collector<T,A,R> downstream,
Function<R,RR> finisher) |
Adapts a
Collector to perform an additional finishing
transformation. |
static <T,A,R> Collector<T,?,R> |
Collectors.filtering(Predicate<? super T> predicate,
Collector<? super T,A,R> downstream) |
Adapts a
Collector to one accepting elements of the same type
T by applying the predicate to each input element and only
accumulating if the predicate returns true . |
static <T,U,A,R> Collector<T,?,R> |
Collectors.flatMapping(Function<? super T,? extends Stream<? extends U>> mapper,
Collector<? super U,A,R> downstream) |
Adapts a
Collector accepting elements of type U to one
accepting elements of type T by applying a flat mapping function
to each input element before accumulation. |
static <T,K,D,A,M extends Map<K,D>> |
Collectors.groupingBy(Function<? super T,? extends K> classifier,
Supplier<M> mapFactory,
Collector<? super T,A,D> downstream) |
Returns a
Collector implementing a cascaded "group by" operation
on input elements of type T , grouping elements according to a
classification function, and then performing a reduction operation on
the values associated with a given key using the specified downstream
Collector . |
static <T,K,A,D> Collector<T,?,Map<K,D>> |
Collectors.groupingBy(Function<? super T,? extends K> classifier,
Collector<? super T,A,D> downstream) |
Returns a
Collector implementing a cascaded "group by" operation
on input elements of type T , grouping elements according to a
classification function, and then performing a reduction operation on
the values associated with a given key using the specified downstream
Collector . |
static <T,K,A,D,M extends ConcurrentMap<K,D>> |
Collectors.groupingByConcurrent(Function<? super T,? extends K> classifier,
Supplier<M> mapFactory,
Collector<? super T,A,D> downstream) |
Returns a concurrent
Collector implementing a cascaded "group by"
operation on input elements of type T , grouping elements
according to a classification function, and then performing a reduction
operation on the values associated with a given key using the specified
downstream Collector . |
static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>> |
Collectors.groupingByConcurrent(Function<? super T,? extends K> classifier,
Collector<? super T,A,D> downstream) |
Returns a concurrent
Collector implementing a cascaded "group by"
operation on input elements of type T , grouping elements
according to a classification function, and then performing a reduction
operation on the values associated with a given key using the specified
downstream Collector . |
static <T,U,A,R> Collector<T,?,R> |
Collectors.mapping(Function<? super T,? extends U> mapper,
Collector<? super U,A,R> downstream) |
Adapts a
Collector accepting elements of type U to one
accepting elements of type T by applying a mapping function to
each input element before accumulation. |
static <T,D,A> Collector<T,?,Map<Boolean,D>> |
Collectors.partitioningBy(Predicate<? super T> predicate,
Collector<? super T,A,D> downstream) |
Returns a
Collector which partitions the input elements according
to a Predicate , reduces the values in each partition according to
another Collector , and organizes them into a
Map<Boolean, D> whose values are the result of the downstream
reduction. |
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2017, Oracle and/or its affiliates. 500 Oracle Parkway
Redwood Shores, CA 94065 USA. All rights reserved.
DRAFT 9-internal+0-adhoc.mlchung.jdk9-jdeps