Package | Description |
---|---|
java.util |
Contains the collections framework, legacy collection classes, event model,
date and time facilities, internationalization, and miscellaneous utility
classes (a string tokenizer, a random-number generator, and a bit array).
|
java.util.concurrent.atomic |
A small toolkit of classes that support lock-free thread-safe
programming on single variables.
|
java.util.function |
Functional interfaces provide target types for lambda expressions
and method references.
|
java.util.stream |
Classes to support functional-style operations on streams of elements, such
as map-reduce transformations on collections.
|
Modifier and Type | Method and Description |
---|---|
static <T> void |
Arrays.parallelPrefix(T[] array,
BinaryOperator<T> op)
Cumulates, in parallel, each element of the given array in place,
using the supplied function.
|
static <T> void |
Arrays.parallelPrefix(T[] array,
int fromIndex,
int toIndex,
BinaryOperator<T> op)
Performs
Arrays.parallelPrefix(Object[], BinaryOperator)
for the given subrange of the array. |
Modifier and Type | Method and Description |
---|---|
E |
AtomicReferenceArray.accumulateAndGet(int i,
E x,
BinaryOperator<E> accumulatorFunction)
Atomically updates the element at index
i with the
results of applying the given function to the current and
given values, returning the updated value. |
V |
AtomicReferenceFieldUpdater.accumulateAndGet(T obj,
V x,
BinaryOperator<V> accumulatorFunction)
Atomically updates the field of the given object managed by this
updater with the results of applying the given function to the
current and given values, returning the updated value.
|
V |
AtomicReference.accumulateAndGet(V x,
BinaryOperator<V> accumulatorFunction)
Atomically updates the current value with the results of
applying the given function to the current and given values,
returning the updated value.
|
E |
AtomicReferenceArray.getAndAccumulate(int i,
E x,
BinaryOperator<E> accumulatorFunction)
Atomically updates the element at index
i with the
results of applying the given function to the current and
given values, returning the previous value. |
V |
AtomicReferenceFieldUpdater.getAndAccumulate(T obj,
V x,
BinaryOperator<V> accumulatorFunction)
Atomically updates the field of the given object managed by this
updater with the results of applying the given function to the
current and given values, returning the previous value.
|
V |
AtomicReference.getAndAccumulate(V x,
BinaryOperator<V> accumulatorFunction)
Atomically updates the current value with the results of
applying the given function to the current and given values,
returning the previous value.
|
Modifier and Type | Method and Description |
---|---|
static <T> BinaryOperator<T> |
BinaryOperator.maxBy(Comparator<? super T> comparator)
Returns a
BinaryOperator which returns the greater of two elements
according to the specified Comparator . |
static <T> BinaryOperator<T> |
BinaryOperator.minBy(Comparator<? super T> comparator)
Returns a
BinaryOperator which returns the lesser of two elements
according to the specified Comparator . |
Modifier and Type | Method and Description |
---|---|
BinaryOperator<A> |
Collector.combiner()
A function that accepts two partial results and merges them.
|
Modifier and Type | Method and Description |
---|---|
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. |
Optional<T> |
Stream.reduce(BinaryOperator<T> accumulator)
Performs a reduction on the
elements of this stream, using an
associative accumulation
function, and returns an
Optional describing the reduced value,
if any. |
T |
Stream.reduce(T identity,
BinaryOperator<T> accumulator)
Performs a reduction on the
elements of this stream, using the provided identity value and an
associative
accumulation function, and returns the reduced value.
|
<U> U |
Stream.reduce(U identity,
BiFunction<U,? super T,U> accumulator,
BinaryOperator<U> combiner)
Performs a reduction on the
elements of this stream, using the provided identity, accumulation and
combining functions.
|
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,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> mapSupplier)
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,?,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> mapSupplier)
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. |
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, 2024, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.