Uses of Interface java.util.concurrent.ConcurrentMap (Java SE 25 & JDK 25)
Description: use: module: java.base, package: java.util.concurrent, interface: ConcurrentMap

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