Uses of Interface java.util.concurrent.ConcurrentMap

Packages that use ConcurrentMap

Package	Description
java.util.concurrent	Utility classes commonly useful in concurrent programming.
java.util.stream	Classes to support functional-style operations on streams of elements, such as map-reduce transformations on collections.

Uses of ConcurrentMap in java.util.concurrent

Subinterfaces of in

Modifier and Type	Interface and Description
`interface`	`ConcurrentNavigableMap<K,V>` A `ConcurrentMap` supporting `NavigableMap` operations, and recursively so for its navigable sub-maps.

Classes in java.util.concurrent that implement ConcurrentMap

Modifier and Type	Class and Description
`class`	`ConcurrentHashMap<K,V>` A hash table supporting full concurrency of retrievals and high expected concurrency for updates.
`class`	`ConcurrentSkipListMap<K,V>` A scalable concurrent `ConcurrentNavigableMap` implementation.

Uses of ConcurrentMap in java.util.stream

Methods in with type parameters of type

Modifier and Type Method and Description

Modifier and Type	Method and Description
`static <T,K,A,D,M extends ConcurrentMap<K,D>> Collector<T,?,M>`	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,U,M extends ConcurrentMap<K,U>> Collector<T,?,M>`	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,A,D,M extends ConcurrentMap<K,D>> Collector<T,?,M>

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,U,M extends ConcurrentMap<K,U>> Collector<T,?,M>

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.

Methods in java.util.stream that return types with arguments of type ConcurrentMap

Modifier and Type	Method and Description
`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> 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,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.