Class AbstractMap<K,V>

The main constructor, for use by subclasses.

Remove all entries from this Map (optional operation). This default implementation calls entrySet().clear(). NOTE: If the entry set does not permit clearing, then this will fail, too. Subclasses often override this for efficiency. Your implementation of entrySet() should not call AbstractMap.clear unless you want an infinite loop.

Throws: UnsupportedOperationException if entrySet().clear() does not support clearing.

See Also: clear

Create a shallow copy of this Map, no keys or values are copied. The default implementation simply calls super.clone().

Returns: the shallow clone

Throws: CloneNotSupportedException if a subclass is not Cloneable

See Also: Cloneable clone

Returns true if this contains a mapping for the given key. This implementation does a linear search, O(n), over the entrySet(), returning true if a match is found, false if the iteration ends. Many subclasses can implement this more efficiently.

Parameters: key the key to search for

Returns: true if the map contains the key

Throws: NullPointerException if key is null but the map does not permit null keys

See Also: containsValue

Returns true if this contains at least one mapping with the given value. This implementation does a linear search, O(n), over the entrySet(), returning true if a match is found, false if the iteration ends. A match is defined as a value, v, where (value == null ? v == null : value.equals(v)). Subclasses are unlikely to implement this more efficiently.

Parameters: value the value to search for

Returns: true if the map contains the value

See Also: containsKey

Returns a set view of the mappings in this Map. Each element in the set must be an implementation of Map.Entry. The set is backed by the map, so that changes in one show up in the other. Modifications made while an iterator is in progress cause undefined behavior. If the set supports removal, these methods must be valid: Iterator.remove, Set.remove, removeAll, retainAll, and clear. Element addition is not supported via this set.

Returns: the entry set

See Also: Entry

Compares the specified object with this map for equality. Returns true if the other object is a Map with the same mappings, that is,
o instanceof Map && entrySet().equals(((Map) o).entrySet();

Parameters: o the object to be compared

Returns: true if the object equals this map

See Also: equals

Returns the value mapped by the given key. Returns null if there is no mapping. However, in Maps that accept null values, you must rely on containsKey to determine if a mapping exists. This iteration takes linear time, searching entrySet().iterator() of the key. Many implementations override this method.

Parameters: key the key to look up

Returns: the value associated with the key, or null if key not in map

Throws: NullPointerException if this map does not accept null keys

See Also: containsKey

Returns the hash code for this map. As defined in Map, this is the sum of all hashcodes for each Map.Entry object in entrySet, or basically entrySet().hashCode().

Returns: the hash code

See Also: hashCode hashCode

Returns true if the map contains no mappings. This is implemented by size() == 0.

Returns: true if the map is empty

See Also: size

Returns a set view of this map's keys. The set is backed by the map, so changes in one show up in the other. Modifications while an iteration is in progress produce undefined behavior. The set supports removal if entrySet() does, but does not support element addition.

This implementation creates an AbstractSet, where the iterator wraps the entrySet iterator, size defers to the Map's size, and contains defers to the Map's containsKey. The set is created on first use, and returned on subsequent uses, although since no synchronization occurs, there is a slight possibility of creating two sets.

Returns: a Set view of the keys

See Also: iterator size containsKey values

Associates the given key to the given value (optional operation). If the map already contains the key, its value is replaced. This implementation simply throws an UnsupportedOperationException. Be aware that in a map that permits null values, a null return does not always imply that the mapping was created.

Parameters: key the key to map value the value to be mapped

Returns: the previous value of the key, or null if there was no mapping

Throws: UnsupportedOperationException if the operation is not supported ClassCastException if the key or value is of the wrong type IllegalArgumentException if something about this key or value prevents it from existing in this map NullPointerException if the map forbids null keys or values

See Also: containsKey

Copies all entries of the given map to this one (optional operation). If the map already contains a key, its value is replaced. This implementation simply iterates over the map's entrySet(), calling put, so it is not supported if puts are not.

Parameters: m the mapping to load into this map

Throws: UnsupportedOperationException if the operation is not supported by this map. ClassCastException if a key or value is of the wrong type for adding to this map. IllegalArgumentException if something about a key or value prevents it from existing in this map. NullPointerException if the map forbids null keys or values. NullPointerException if m is null.

See Also: AbstractMap

Removes the mapping for this key if present (optional operation). This implementation iterates over the entrySet searching for a matching key, at which point it calls the iterator's remove method. It returns the result of getValue() on the entry, if found, or null if no entry is found. Note that maps which permit null values may also return null if the key was removed. If the entrySet does not support removal, this will also fail. This is O(n), so many implementations override it for efficiency.

Parameters: key the key to remove

Returns: the value the key mapped to, or null if not present. Null may also be returned if null values are allowed in the map and the value of this mapping is null.

Throws: UnsupportedOperationException if deletion is unsupported

See Also: remove

Returns the number of key-value mappings in the map. If there are more than Integer.MAX_VALUE mappings, return Integer.MAX_VALUE. This is implemented as entrySet().size().

Returns: the number of mappings

See Also: size

Returns a String representation of this map. This is a listing of the map entries (which are specified in Map.Entry as being getKey() + "=" + getValue()), separated by a comma and space (", "), and surrounded by braces ('{' and '}'). This implementation uses a StringBuffer and iterates over the entrySet to build the String. Note that this can fail with an exception if underlying keys or values complete abruptly in toString().

Returns: a String representation

See Also: Entry

Returns a collection or bag view of this map's values. The collection is backed by the map, so changes in one show up in the other. Modifications while an iteration is in progress produce undefined behavior. The collection supports removal if entrySet() does, but does not support element addition.

This implementation creates an AbstractCollection, where the iterator wraps the entrySet iterator, size defers to the Map's size, and contains defers to the Map's containsValue. The collection is created on first use, and returned on subsequent uses, although since no synchronization occurs, there is a slight possibility of creating two collections.

Returns: a Collection view of the values

See Also: iterator size containsValue keySet