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

Copyright © 1993, 2017, Oracle and/or its affiliates. All rights reserved.