java.util.concurrent

## Interface ConcurrentMap<K,V>

- Type Parameters:
    `K` - the type of keys maintained by this map
    `V` - the type of mapped values
  All Superinterfaces:
    Map<K,V>
  All Known Subinterfaces:
    ConcurrentNavigableMap<K,V>
  All Known Implementing Classes:
    ConcurrentHashMap, ConcurrentSkipListMap

      public interface ConcurrentMap<K,V>
      extends Map<K,V>

  A `Map` providing additional atomic `putIfAbsent`, `remove`, and `replace` methods.

  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.

  Since:
    1.5

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface java.util.Map

      `Map.Entry<K,V>`

  - ### Method Summary

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

    - ### Methods inherited from interface java.util.Map

      `clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, values`

- - ### Method Detail

    - #### putIfAbsent

          V putIfAbsent(K key,
                      V value)

      If the specified key is not already associated with a value, associate it with the given value. This is equivalent to

             if (!map.containsKey(key))
                 return map.put(key, value);
             else
                 return map.get(key);

      except that the action is performed atomically.
      Parameters:
        `key` - key with which the specified value is to be associated
        `value` - value to be associated with the specified key
      Returns:
        the previous value associated with the specified key, or `null` 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.)
      Throws:
        `UnsupportedOperationException` - if the `put` operation is not supported by this map
        `ClassCastException` - if the class of the specified key or value prevents it from being stored in this map
        `NullPointerException` - if the specified key or value is null, and this map does not permit null keys or values
        `IllegalArgumentException` - if some property of the specified key or value prevents it from being stored in this map

    - #### remove

          boolean remove(Object key,
                       Object value)

      Removes the entry for a key only if currently mapped to a given value. This is equivalent to

             if (map.containsKey(key) && map.get(key).equals(value)) {
                 map.remove(key);
                 return true;
             } else return false;

      except that the action is performed atomically.
      Parameters:
        `key` - key with which the specified value is associated
        `value` - value expected to be associated with the specified key
      Returns:
        `true` if the value was removed
      Throws:
        `UnsupportedOperationException` - if the `remove` operation is not supported by this map
        `ClassCastException` - 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)

    - #### replace

          boolean replace(K key,
                        V oldValue,
                        V newValue)

      Replaces the entry for a key only if currently mapped to a given value. This is equivalent to

             if (map.containsKey(key) && map.get(key).equals(oldValue)) {
                 map.put(key, newValue);
                 return true;
             } else return false;

      except that the action is performed atomically.
      Parameters:
        `key` - key with which the specified value is associated
        `oldValue` - value expected to be associated with the specified key
        `newValue` - value to be associated with the specified key
      Returns:
        `true` if the value was replaced
      Throws:
        `UnsupportedOperationException` - if the `put` operation is not supported by this map
        `ClassCastException` - if the class of a specified key or value prevents it from being stored in this map
        `NullPointerException` - if a specified key or value is null, and this map does not permit null keys or values
        `IllegalArgumentException` - if some property of a specified key or value prevents it from being stored in this map

    - #### replace

          V replace(K key,
                  V value)

      Replaces the entry for a key only if currently mapped to some value. This is equivalent to

             if (map.containsKey(key)) {
                 return map.put(key, value);
             } else return null;

      except that the action is performed atomically.
      Parameters:
        `key` - key with which the specified value is associated
        `value` - value to be associated with the specified key
      Returns:
        the previous value associated with the specified key, or `null` 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.)
      Throws:
        `UnsupportedOperationException` - if the `put` operation is not supported by this map
        `ClassCastException` - if the class of the specified key or value prevents it from being stored in this map
        `NullPointerException` - if the specified key or value is null, and this map does not permit null keys or values
        `IllegalArgumentException` - if some property of the specified key or value prevents it from being stored in this map

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, 2014, Oracle and/or its affiliates. All rights reserved.