K - the type of keys maintained by this mapV - the type of mapped valuespublic interface ConcurrentMap<K,V> extends Map<K,V>
Map providing thread safety and atomicity
 guarantees.
 Memory consistency effects: As with other concurrent
 collections, actions in a thread prior to placing an object into a
 ConcurrentMap as a key or value
 happen-before
 actions subsequent to the access or removal of that object from
 the ConcurrentMap in another thread.
 
This interface is a member of the Java Collections Framework.
| Modifier and Type | Method and Description | 
|---|---|
| default V | compute(K key,
       BiFunction<? super K,? super V,? extends V> remappingFunction)Attempts to compute a mapping for the specified key and its current
 mapped value (or  nullif there is no current mapping). | 
| default V | computeIfAbsent(K key,
               Function<? super K,? extends V> mappingFunction)If the specified key is not already associated with a value (or is mapped
 to  null), attempts to compute its value using the given mapping
 function and enters it into this map unlessnull. | 
| default V | computeIfPresent(K key,
                BiFunction<? super K,? super V,? extends V> remappingFunction)If the value for the specified key is present and non-null, attempts to
 compute a new mapping given the key and its current mapped value. | 
| default void | forEach(BiConsumer<? super K,? super V> action)Performs the given action for each entry in this map until all entries
 have been processed or the action throws an exception. | 
| default V | getOrDefault(Object key,
            V defaultValue)Returns the value to which the specified key is mapped, or
  defaultValueif this map contains no mapping for the key. | 
| default V | merge(K key,
     V value,
     BiFunction<? super V,? super V,? extends V> remappingFunction)If the specified key is not already associated with a value or is
 associated with null, associates it with the given non-null value. | 
| V | putIfAbsent(K key,
           V value)If the specified key is not already associated
 with a value, associate it with the given value. | 
| boolean | remove(Object key,
      Object value)Removes the entry for a key only if currently mapped to a given value. | 
| V | replace(K key,
       V value)Replaces the entry for a key only if currently mapped to some value. | 
| boolean | replace(K key,
       V oldValue,
       V newValue)Replaces the entry for a key only if currently mapped to a given value. | 
| default void | replaceAll(BiFunction<? super K,? super V,? extends V> function)Replaces each entry's value with the result of invoking the given
 function on that entry until all entries have been processed or the
 function throws an exception. | 
default V getOrDefault(Object key, V defaultValue)
defaultValue if this map contains no mapping for the key.getOrDefault in interface Map<K,V>get() returning null unambiguously means
 the key is absent. Implementations which support null values
 must override this default implementation.key - the key whose associated value is to be returneddefaultValue - the default mapping of the keydefaultValue if this map contains no mapping for the keyClassCastException - if the key is of an inappropriate type for
 this map
 (optional)NullPointerException - if the specified key is null and this map
 does not permit null keys
 (optional)default void forEach(BiConsumer<? super K,? super V> action)
forEach in interface Map<K,V>map:
  
 for ((Map.Entry<K, V> entry : map.entrySet())
     action.accept(entry.getKey(), entry.getValue());
 IllegalStateException thrown by getKey() or
 getValue() indicates that the entry has been removed and cannot
 be processed. Operation continues for subsequent entries.action - The action to be performed for each entryNullPointerException - if the specified action is nullV putIfAbsent(K key, V value)
 
 if (!map.containsKey(key))
   return map.put(key, value);
 else
   return map.get(key);
 
 except that the action is performed atomically.putIfAbsent in interface Map<K,V>Map.key - key with which the specified value is to be associatedvalue - value to be associated with the specified keynull if there was no mapping for the key.
         (A null return can also indicate that the map
         previously associated null with the key,
         if the implementation supports null values.)UnsupportedOperationException - if the put operation
         is not supported by this mapClassCastException - if the class of the specified key or value
         prevents it from being stored in this mapNullPointerException - if the specified key or value is null,
         and this map does not permit null keys or valuesIllegalArgumentException - if some property of the specified key
         or value prevents it from being stored in this mapboolean remove(Object key, Object value)
 
 if (map.containsKey(key) && Objects.equals(map.get(key), value)) {
   map.remove(key);
   return true;
 } else
   return false;
 
 except that the action is performed atomically.remove in interface Map<K,V>Map.key - key with which the specified value is associatedvalue - value expected to be associated with the specified keytrue if the value was removedUnsupportedOperationException - if the remove operation
         is not supported by this mapClassCastException - if the key or value is of an inappropriate
         type for this map
         (optional)NullPointerException - if the specified key or value is null,
         and this map does not permit null keys or values
         (optional)boolean replace(K key, V oldValue, V newValue)
 
 if (map.containsKey(key) && Objects.equals(map.get(key), oldValue)) {
   map.put(key, newValue);
   return true;
 } else
   return false;
 
 except that the action is performed atomically.replace in interface Map<K,V>Map.key - key with which the specified value is associatedoldValue - value expected to be associated with the specified keynewValue - value to be associated with the specified keytrue if the value was replacedUnsupportedOperationException - if the put operation
         is not supported by this mapClassCastException - if the class of a specified key or value
         prevents it from being stored in this mapNullPointerException - if a specified key or value is null,
         and this map does not permit null keys or valuesIllegalArgumentException - if some property of a specified key
         or value prevents it from being stored in this mapV replace(K key, V value)
 
 if (map.containsKey(key)) {
   return map.put(key, value);
 } else
   return null;
 
 except that the action is performed atomically.replace in interface Map<K,V>Map.key - key with which the specified value is associatedvalue - value to be associated with the specified keynull if there was no mapping for the key.
         (A null return can also indicate that the map
         previously associated null with the key,
         if the implementation supports null values.)UnsupportedOperationException - if the put operation
         is not supported by this mapClassCastException - if the class of the specified key or value
         prevents it from being stored in this mapNullPointerException - if the specified key or value is null,
         and this map does not permit null keys or valuesIllegalArgumentException - if some property of the specified key
         or value prevents it from being stored in this mapdefault void replaceAll(BiFunction<? super K,? super V,? extends V> function)
replaceAll in interface Map<K,V>The default implementation is equivalent to, for this map:
 
 
 for ((Map.Entry<K, V> entry : map.entrySet())
     do {
        K k = entry.getKey();
        V v = entry.getValue();
     } while(!replace(k, v, function.apply(k, v)));
 
 The default implementation may retry these steps when multiple
 threads attempt updates including potentially calling the function
 repeatedly for a given key.
 This implementation assumes that the ConcurrentMap cannot contain null
 values and get() returning null unambiguously means the key is
 absent. Implementations which support null values must
 override this default implementation.
function - the function to apply to each entryUnsupportedOperationException - if the set operation
 is not supported by this map's entry set iterator.NullPointerException - if function or a replacement value is null,
         and this map does not permit null keys or values
         (optional)ClassCastException - if a replacement value is of an inappropriate
         type for this map
         (optional)IllegalArgumentException - if some property of a replacement value
         prevents it from being stored in this map
         (optional)default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
null), attempts to compute its value using the given mapping
 function and enters it into this map unless null.
 If the function returns null no mapping is recorded. If
 the function itself throws an (unchecked) exception, the
 exception is rethrown, and no mapping is recorded.  The most
 common usage is to construct a new object serving as an initial
 mapped value or memoized result, as in:
 
 
 map.computeIfAbsent(key, k -> new Value(f(k)));
 
 Or to implement a multi-value map, Map<K,Collection<V>>,
 supporting multiple values per key:
 
 
 map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
 computeIfAbsent in interface Map<K,V>map, then returning the current value or null if now
 absent:
  
 if (map.get(key) == null) {
     V newValue = mappingFunction.apply(key);
     if (newValue != null)
         return map.putIfAbsent(key, newValue);
 }
 
 The default implementation may retry these steps when multiple
 threads attempt updates including potentially calling the mapping
 function multiple times.
 This implementation assumes that the ConcurrentMap cannot contain null
 values and get() returning null unambiguously means the key is
 absent. Implementations which support null values must
 override this default implementation.
key - key with which the specified value is to be associatedmappingFunction - the function to compute a valueUnsupportedOperationException - if the put operation
         is not supported by this map
         (optional)ClassCastException - if the class of the specified key or value
         prevents it from being stored in this map
         (optional)NullPointerException - if the specified key is null and
         this map does not support null keys, or the mappingFunction
         is nulldefault V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
If the function returns null, the mapping is removed.  If the
 function itself throws an (unchecked) exception, the exception is
 rethrown, and the current mapping is left unchanged.
computeIfPresent in interface Map<K,V>map, then returning the current value or
 null if now absent. :
  
 if (map.get(key) != null) {
     V oldValue = map.get(key);
     V newValue = remappingFunction.apply(key, oldValue);
     if (newValue != null)
         map.replace(key, oldValue, newValue);
     else
         map.remove(key, oldValue);
 }
 
 The default implementation may retry these steps when multiple threads
 attempt updates including potentially calling the remapping function
 multiple times.
 This implementation assumes that the ConcurrentMap cannot contain null
 values and get() returning null unambiguously means the key is
 absent. Implementations which support null values must
 override this default implementation.
key - key with which the specified value is to be associatedremappingFunction - the function to compute a valueUnsupportedOperationException - if the put operation
         is not supported by this map
         (optional)ClassCastException - if the class of the specified key or value
         prevents it from being stored in this map
         (optional)NullPointerException - if the specified key is null and
         this map does not support null keys, or the
         remappingFunction is nulldefault V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
null if there is no current mapping). For
 example, to either create or append a String msg to a value
 mapping:
  
 map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))
 (Method merge() is often simpler to use for such purposes.)
 If the function returns null, the mapping is removed (or
 remains absent if initially absent).  If the function itself throws an
 (unchecked) exception, the exception is rethrown, and the current mapping
 is left unchanged.
compute in interface Map<K,V>map, then returning the current value or
 null if absent:
  
 V oldValue = map.get(key);
 V newValue = remappingFunction.apply(key, oldValue);
 if (oldValue != null ) {
    if (newValue != null)
       map.replace(key, oldValue, newValue);
    else
       map.remove(key, oldValue);
 } else {
    if (newValue != null)
       map.putIfAbsent(key, newValue);
    else
       return null;
 }
 
 The default implementation may retry these steps when multiple
 threads attempt updates including potentially calling the remapping
 function multiple times.
 This implementation assumes that the ConcurrentMap cannot contain null
 values and get() returning null unambiguously means the key is
 absent. Implementations which support null values must
 override this default implementation.
key - key with which the specified value is to be associatedremappingFunction - the function to compute a valueUnsupportedOperationException - if the put operation
         is not supported by this map
         (optional)ClassCastException - if the class of the specified key or value
         prevents it from being stored in this map
         (optional)NullPointerException - if the specified key is null and
         this map does not support null keys, or the
         remappingFunction is nulldefault V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
null. This
 method may be of use when combining multiple mapped values for a key.
 For example, to either create or append a String msg to a
 value mapping:
  
 map.merge(key, msg, String::concat)
 
 If the function returns null the mapping is removed.  If the
 function itself throws an (unchecked) exception, the exception is
 rethrown, and the current mapping is left unchanged.
merge in interface Map<K,V>map, then returning the current value or
 null if absent:
  
 V oldValue = map.get(key);
 V newValue = (oldValue == null) ? value :
              remappingFunction.apply(oldValue, value);
 if (newValue == null)
     map.remove(key);
 else
     map.put(key, newValue);
 
 The default implementation may retry these steps when multiple threads attempt updates including potentially calling the remapping function multiple times.
This implementation assumes that the ConcurrentMap cannot contain null
 values and get() returning null unambiguously means the key is
 absent. Implementations which support null values must
 override this default implementation.
key - key with which the resulting value is to be associatedvalue - the non-null value to be merged with the existing value
        associated with the key or, if no existing value or a null value
        is associated with the key, to be associated with the keyremappingFunction - the function to recompute a value if presentUnsupportedOperationException - if the put operation
         is not supported by this map
         (optional)ClassCastException - if the class of the specified key or value
         prevents it from being stored in this map
         (optional)NullPointerException - if the specified key is null and this map
         does not support null keys or the value or remappingFunction is
         null 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, 2025, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.