| 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  iwith 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  iwith 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  BinaryOperatorwhich returns the greater of two elements
 according to the specifiedComparator. | 
| static <T> BinaryOperator<T> | BinaryOperator. minBy(Comparator<? super T> comparator)Returns a  BinaryOperatorwhich returns the lesser of two elements
 according to the specifiedComparator. | 
| 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  Collectordescribed by the givensupplier,accumulator,combiner, andfinisherfunctions. | 
| 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  Collectordescribed by the givensupplier,accumulator, andcombinerfunctions. | 
| Optional<T> | Stream. reduce(BinaryOperator<T> accumulator)Performs a reduction on the
 elements of this stream, using an
 associative accumulation
 function, and returns an  Optionaldescribing 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  Collectorwhich performs a reduction of its
 input elements under a specifiedBinaryOperator. | 
| static <T> Collector<T,?,T> | Collectors. reducing(T identity,
        BinaryOperator<T> op)Returns a  Collectorwhich performs a reduction of its
 input elements under a specifiedBinaryOperatorusing the
 provided identity. | 
| static <T,U> Collector<T,?,U> | Collectors. reducing(U identity,
        Function<? super T,? extends U> mapper,
        BinaryOperator<U> op)Returns a  Collectorwhich performs a reduction of its
 input elements under a specified mapping function andBinaryOperator. | 
| 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  Collectorthat accumulates elements into aConcurrentMapwhose 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  Collectorthat accumulates elements into aConcurrentMapwhose 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  Collectorthat accumulates elements into aMapwhose 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  Collectorthat accumulates elements into aMapwhose 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, 2017, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.