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

- Packages that use ConcurrentMap
  Package | Description
  --- | ---
  java.net.http | HTTP Client and WebSocket APIs
  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.net.http

    Methods in java.net.http with parameters of type ConcurrentMap
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <T> HttpResponse.PushPromiseHandler<T>` | HttpResponse.PushPromiseHandler.`of​(Function<HttpRequest,​HttpResponse.BodyHandler<T>> pushPromiseHandler, ConcurrentMap<HttpRequest,​CompletableFuture<HttpResponse<T>>> pushPromisesMap)` | Returns a push promise handler that accumulates push promises, and their responses, into the given map.

  - ### Uses of ConcurrentMap in java.util.concurrent

    Subinterfaces of ConcurrentMap in java.util.concurrent
    Modifier and Type | Interface | 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 | 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 java.util.stream with type parameters of type ConcurrentMap
    Modifier and Type | Method | 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> 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.

    Methods in java.util.stream that return types with arguments of type ConcurrentMap
    Modifier and Type | Method | 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.