Package Summary Overview Summary

### class:AbstractMap [NONE]
- 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`

### constructor:<init>() [NONE]
- #### AbstractMap
      protected AbstractMap()
Sole constructor. (For invocation by subclass constructors, typically implicit.)

### method:size() [NONE]
- #### 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

### method:isEmpty() [NONE]
- #### 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

### method:containsValue(java.lang.Object) [NONE]
- #### 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)

### method:containsKey(java.lang.Object) [NONE]
- #### 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)

### method:get(java.lang.Object) [NONE]
- #### 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)

### method:put(K,V) [NONE]
- #### 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

### method:remove(java.lang.Object) [NONE]
- #### 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)

### method:putAll(java.util.Map) [NONE]
- #### 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. 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

### method:clear() [NONE]
- #### 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

### method:keySet() [NONE]
- #### 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

### method:values() [NONE]
- #### 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

### method:equals(java.lang.Object) [NONE]
- #### 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`

### method:hashCode() [NONE]
- #### 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)`

### method:toString() [NONE]
- #### 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

### method:clone() [NONE]
- #### 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`