## Uses of Interface
java.util.concurrent.ConcurrentMap

Packages that use ConcurrentMap
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 ConcurrentMap in java.util.concurrent
`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
`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 java.util.stream with type parameters of type ConcurrentMap

`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
`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.