AbstractMap (Java SE 25 & JDK 25)
Description: declaration: module: java.base, package: java.util, class: AbstractMap
Keywords: java.util.AbstractMap class

# Class AbstractMap<K,V>

java.lang.Object
java.util.AbstractMap<K,V>

Type Parameters:
  `K` - the type of keys maintained by this map
  `V` - the type of mapped values

All Implemented Interfaces:
  `Map<K,V>`

Direct Known Subclasses:
  `ConcurrentHashMap, ConcurrentSkipListMap, EnumMap, HashMap, IdentityHashMap, TreeMap, WeakHashMap`

public abstract class AbstractMap<K,V> extends Object implements Map<K,V>
This class provides a skeletal implementation of the `Map` interface, to minimize the effort required to implement this interface.

To implement an unmodifiable map, the programmer needs only to extend this class and provide an implementation for the `entrySet` method, which returns a set-view of the map's mappings. Typically, the returned set will, in turn, be implemented atop `AbstractSet`. This set should not support the `add` or `remove` methods, and its iterator should not support the `remove` method.

To implement a modifiable map, the programmer must additionally override this class's `put` method (which otherwise throws an `UnsupportedOperationException`), and the iterator returned by `entrySet().iterator()` must additionally implement its `remove` method.

The programmer should generally provide a void (no argument) and map constructor, as per the recommendation in the `Map` interface specification.

The documentation for each non-abstract method in this class describes its implementation in detail. Each of these methods may be overridden if the map being implemented admits a more efficient implementation.

This class is a member of the Java Collections Framework.

Since:
  1.2
See Also:
  - `Map`
  - `Collection`

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static class`
  `AbstractMap.SimpleEntry<K,V>`
  An Entry maintaining a key and a value.
  `static class`
  `AbstractMap.SimpleImmutableEntry<K,V>`
  An unmodifiable Entry maintaining a key and a value.

  ### Nested classes/interfaces declared in interface Map

  `Map.Entry<K,V>`

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `AbstractMap()`
  Sole constructor.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `clear()`
  Removes all of the mappings from this map (optional operation).
  `protected Object`
  `clone()`
  Returns a shallow copy of this `AbstractMap` instance: the keys and values themselves are not cloned.
  `boolean`
  `containsKey(Object key)`
  Returns `true` if this map contains a mapping for the specified key.
  `boolean`
  `containsValue(Object value)`
  Returns `true` if this map maps one or more keys to the specified value.
  `boolean`
  `equals(Object o)`
  Compares the specified object with this map for equality.
  `V`
  `get(Object key)`
  Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.
  `int`
  `hashCode()`
  Returns the hash code value for this map.
  `boolean`
  `isEmpty()`
  Returns `true` if this map contains no key-value mappings.
  `Set<K>`
  `keySet()`
  Returns a `Set` view of the keys contained in this map.
  `V`
  `put(K key, V value)`
  Associates the specified value with the specified key in this map (optional operation).
  `void`
  `putAll(Map<? extends K, ? extends V> m)`
  Copies all of the mappings from the specified map to this map (optional operation).
  `V`
  `remove(Object key)`
  Removes the mapping for a key from this map if it is present (optional operation).
  `int`
  `size()`
  Returns the number of key-value mappings in this map.
  `String`
  `toString()`
  Returns a string representation of this map.
  `Collection<V>`
  `values()`
  Returns a `Collection` view of the values contained in this map.

  ### Methods declared in class Object

  `finalize, getClass, notify, notifyAll, wait, wait, wait`

  ### Methods declared in interface Map

  `compute, computeIfAbsent, computeIfPresent, entrySet, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll`

- ## Constructor Details

  - ### AbstractMap

    protected AbstractMap()
    Sole constructor. (For invocation by subclass constructors, typically implicit.)

- ## Method Details

  - ### size

    public int size()
    Returns the number of key-value mappings in this map. If the map contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`.
    Specified by:
      `size` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation returns `entrySet().size()`.
    Returns:
      the number of key-value mappings in this map

  - ### isEmpty

    public boolean isEmpty()
    Returns `true` if this map contains no key-value mappings.
    Specified by:
      `isEmpty` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation returns `size() == 0`.
    Returns:
      `true` if this map contains no key-value mappings

  - ### containsValue

    public boolean containsValue(Object value)
    Returns `true` if this map maps one or more keys to the specified value. More formally, returns `true` if and only if this map contains at least one mapping to a value `v` such that `Objects.equals(value, v)`. This operation will probably require time linear in the map size for most implementations of the `Map` interface.
    Specified by:
      `containsValue` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation iterates over `entrySet()` searching for an entry with the specified value. If such an entry is found, `true` is returned. If the iteration terminates without finding such an entry, `false` is returned. Note that this implementation requires linear time in the size of the map.
    Parameters:
      `value` - value whose presence in this map is to be tested
    Returns:
      `true` if this map maps one or more keys to the specified value
    Throws:
      `ClassCastException` - if the value is of an inappropriate type for this map (optional)
      `NullPointerException` - if the specified value is null and this map does not permit null values (optional)

  - ### containsKey

    public boolean containsKey(Object key)
    Returns `true` if this map contains a mapping for the specified key. More formally, returns `true` if and only if this map contains a mapping for a key `k` such that `Objects.equals(key, k)`. (There can be at most one such mapping.)
    Specified by:
      `containsKey` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation iterates over `entrySet()` searching for an entry with the specified key. If such an entry is found, `true` is returned. If the iteration terminates without finding such an entry, `false` is returned. Note that this implementation requires linear time in the size of the map; many implementations will override this method.
    Parameters:
      `key` - key whose presence in this map is to be tested
    Returns:
      `true` if this map contains a mapping for the specified key
    Throws:
      `ClassCastException` - 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)

  - ### get

    public V get(Object key)
    Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.

    More formally, if this map contains a mapping from a key `k` to a value `v` such that `Objects.equals(key, k)`, then this method returns `v`; otherwise it returns `null`. (There can be at most one such mapping.)

    If this map permits null values, then a return value of `null` does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to `null`. The `containsKey` operation may be used to distinguish these two cases.

    Specified by:
      `get` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation iterates over `entrySet()` searching for an entry with the specified key. If such an entry is found, the entry's value is returned. If the iteration terminates without finding such an entry, `null` is returned. Note that this implementation requires linear time in the size of the map; many implementations will override this method.
    Parameters:
      `key` - the key whose associated value is to be returned
    Returns:
      the value to which the specified key is mapped, or `null` if this map contains no mapping for the key
    Throws:
      `ClassCastException` - 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)

  - ### put

    public V put(K key, V value)
    Associates the specified value with the specified key in this map (optional operation). If the map previously contained a mapping for the key, the old value is replaced by the specified value. (A map `m` is said to contain a mapping for a key `k` if and only if `m.containsKey(k)` would return `true`.)
    Specified by:
      `put` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation always throws an `UnsupportedOperationException`.
    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 `key`, or `null` if there was no mapping for `key`. (A `null` return can also indicate that the map previously associated `null` with `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

    public V remove(Object key)
    Removes the mapping for a key from this map if it is present (optional operation). More formally, if this map contains a mapping from key `k` to value `v` such that `Objects.equals(key, k)`, that mapping is removed. (The map can contain at most one such mapping.)

    Returns the value to which this map previously associated the key, or `null` if the map contained no mapping for the key.

    If this map permits null values, then a return value of `null` does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to `null`.

    The map will not contain a mapping for the specified key once the call returns.

    Specified by:
      `remove` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation iterates over `entrySet()` searching for an entry with the specified key. If such an entry is found, its value is obtained with its `getValue` operation, the entry is removed from the collection (and the backing map) with the iterator's `remove` operation, and the saved value is returned. If the iteration terminates without finding such an entry, `null` is returned. Note that this implementation requires linear time in the size of the map; many implementations will override this method.

      Note that this implementation throws an `UnsupportedOperationException` if the `entrySet` iterator does not support the `remove` method and this map contains a mapping for the specified key.

    Parameters:
      `key` - key whose mapping is to be removed from the map
    Returns:
      the previous value associated with `key`, or `null` if there was no mapping for `key`.
    Throws:
      `UnsupportedOperationException` - if the `remove` operation is not supported by this map
      `ClassCastException` - 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)

  - ### putAll

    public void putAll(Map<? extends K, ? extends V> m)
    Copies all of the mappings from the specified map to this map (optional operation). The effect of this call is equivalent to that of calling `put(k, v)` on this map once for each mapping from key `k` to value `v` in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress. If the specified map has a defined encounter order, processing of its mappings generally occurs in that order.
    Specified by:
      `putAll` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation iterates over the specified map's `entrySet()` collection, and calls this map's `put` operation once for each entry returned by the iteration.

      Note that this implementation throws an `UnsupportedOperationException` if this map does not support the `put` operation and the specified map is nonempty.

    Parameters:
      `m` - mappings to be stored in this map
    Throws:
      `UnsupportedOperationException` - if the `putAll` operation is not supported by this map
      `ClassCastException` - if the class of a key or value in the specified map prevents it from being stored in this map
      `NullPointerException` - if the specified map is null, or if this map does not permit null keys or values, and the specified map contains null keys or values
      `IllegalArgumentException` - if some property of a key or value in the specified map prevents it from being stored in this map

  - ### clear

    public void clear()
    Removes all of the mappings from this map (optional operation). The map will be empty after this call returns.
    Specified by:
      `clear` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation calls `entrySet().clear()`.

      Note that this implementation throws an `UnsupportedOperationException` if the `entrySet` does not support the `clear` operation.

    Throws:
      `UnsupportedOperationException` - if the `clear` operation is not supported by this map

  - ### keySet

    public Set<K> keySet()
    Returns a `Set` view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll`, and `clear` operations. It does not support the `add` or `addAll` operations.
    Specified by:
      `keySet` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation returns a set that subclasses `AbstractSet`. The subclass's iterator method returns a "wrapper object" over this map's `entrySet()` iterator. The `size` method delegates to this map's `size` method and the `contains` method delegates to this map's `containsKey` method.

      The set is created the first time this method is called, and returned in response to all subsequent calls. No synchronization is performed, so there is a slight chance that multiple calls to this method will not all return the same set.

    Returns:
      a set view of the keys contained in this map

  - ### values

    public Collection<V> values()
    Returns a `Collection` view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Collection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.
    Specified by:
      `values` in interface `Map<K,V>`
    Implementation Requirements:
      This implementation returns a collection that subclasses `AbstractCollection`. The subclass's iterator method returns a "wrapper object" over this map's `entrySet()` iterator. The `size` method delegates to this map's `size` method and the `contains` method delegates to this map's `containsValue` method.

      The collection is created the first time this method is called, and returned in response to all subsequent calls. No synchronization is performed, so there is a slight chance that multiple calls to this method will not all return the same collection.

    Returns:
      a collection view of the values contained in this map

  - ### equals

    public boolean equals(Object o)
    Compares the specified object with this map for equality. Returns `true` if the given object is also a map and the two maps represent the same mappings. More formally, two maps `m1` and `m2` represent the same mappings if `m1.entrySet().equals(m2.entrySet())`. This ensures that the `equals` method works properly across different implementations of the `Map` interface.
    Specified by:
      `equals` in interface `Map<K,V>`
    Overrides:
      `equals` in class `Object`
    Implementation Requirements:
      This implementation first checks if the specified object is this map; if so it returns `true`. Then, it checks if the specified object is a map whose size is identical to the size of this map; if not, it returns `false`. If so, it iterates over this map's `entrySet` collection, and checks that the specified map contains each mapping that this map contains. If the specified map fails to contain such a mapping, `false` is returned. If the iteration completes, `true` is returned.
    Parameters:
      `o` - object to be compared for equality with this map
    Returns:
      `true` if the specified object is equal to this map
    See Also:
      - `Object.hashCode()`
      - `HashMap`

  - ### hashCode

    public int hashCode()
    Returns the hash code value for this map. The hash code of a map is defined to be the sum of the hash codes of each entry in the map's `entrySet()` view. This ensures that `m1.equals(m2)` implies that `m1.hashCode()==m2.hashCode()` for any two maps `m1` and `m2`, as required by the general contract of `Object.hashCode()`.
    Specified by:
      `hashCode` in interface `Map<K,V>`
    Overrides:
      `hashCode` in class `Object`
    Implementation Requirements:
      This implementation iterates over `entrySet()`, calling `hashCode()` on each element (entry) in the set, and adding up the results.
    Returns:
      the hash code value for this map
    See Also:
      - `Map.Entry.hashCode()`
      - `Object.equals(Object)`
      - `Set.equals(Object)`

  - ### toString

    public String toString()
    Returns a string representation of this map. The string representation consists of a list of key-value mappings in the order returned by the map's `entrySet` view's iterator, enclosed in braces (`"{}"`). Adjacent mappings are separated by the characters `", "` (comma and space). Each key-value mapping is rendered as the key followed by an equals sign (`"="`) followed by the associated value. Keys and values are converted to strings as by `String.valueOf(Object)`.
    Overrides:
      `toString` in class `Object`
    Returns:
      a string representation of this map

  - ### clone

    protected Object clone() throws CloneNotSupportedException
    Returns a shallow copy of this `AbstractMap` instance: the keys and values themselves are not cloned.
    Overrides:
      `clone` in class `Object`
    Returns:
      a shallow copy of this map
    Throws:
      `CloneNotSupportedException` - if the object's class does not support the `Cloneable` interface. Subclasses that override the `clone` method can also throw this exception to indicate that an instance cannot be cloned.
    See Also:
      - `Cloneable`