public abstract class AbstractMap extends Object implements Map
entrySet (usually via an
AbstractSet). To make it modifiable, also implement put,
and have entrySet().iterator() support remove.
It is recommended that classes which extend this support at least the no-argument constructor, and a constructor which accepts another Map. Further methods in this class may be overridden if you have a more efficient implementation.
Map,
Collection,
HashMap,
LinkedHashMap,
TreeMap,
WeakHashMap,
IdentityHashMap| Modifier | Constructor and Description |
|---|---|
protected |
AbstractMap()
The main constructor, for use by subclasses.
|
| Modifier and Type | Method and Description |
|---|---|
void |
clear()
Remove all entries from this Map (optional operation).
|
protected Object |
clone()
Create a shallow copy of this Map, no keys or values are copied.
|
boolean |
containsKey(Object key)
Returns true if this contains a mapping for the given key.
|
boolean |
containsValue(Object value)
Returns true if this contains at least one mapping with the given value.
|
abstract Set |
entrySet()
Returns a set view of the mappings in this Map.
|
boolean |
equals(Object o)
Compares the specified object with this map for equality.
|
Object |
get(Object key)
Returns the value mapped by the given key.
|
int |
hashCode()
Returns the hash code for this map.
|
boolean |
isEmpty()
Returns true if the map contains no mappings.
|
Set |
keySet()
Returns a set view of this map's keys.
|
Object |
put(Object key,
Object value)
Associates the given key to the given value (optional operation).
|
void |
putAll(Map m)
Copies all entries of the given map to this one (optional operation).
|
Object |
remove(Object key)
Removes the mapping for this key if present (optional operation).
|
int |
size()
Returns the number of key-value mappings in the map.
|
String |
toString()
Returns a String representation of this map.
|
Collection |
values()
Returns a collection or bag view of this map's values.
|
public void clear()
AbstractMap.clear unless you want an infinite loop.clear in interface MapUnsupportedOperationException - if entrySet().clear()
does not support clearing.Collection.clear()protected Object clone() throws CloneNotSupportedException
super.clone().clone in class ObjectCloneNotSupportedException - if a subclass is not CloneableCloneable,
Object.clone()public boolean containsKey(Object key)
entrySet(), returning true if a match
is found, false if the iteration ends. Many subclasses
can implement this more efficiently.containsKey in interface Mapkey - the key to search forNullPointerException - if key is null but the map
does not permit null keyscontainsValue(Object)public boolean containsValue(Object value)
entrySet(), returning true if a match
is found, false if the iteration ends. A match is
defined as (value == null ? v == null : value.equals(v))
Subclasses are unlikely to implement this more efficiently.containsValue in interface Mapvalue - the value to search forcontainsKey(Object)public abstract Set entrySet()
Iterator.remove, Set.remove,
removeAll, retainAll, and clear.
Element addition is not supported via this set.public boolean equals(Object o)
true if the other object is a Map with the same mappings,
that is,o instanceof Map && entrySet().equals(((Map) o).entrySet();equals in interface Mapequals in class Objecto - the object to be comparedCollection.equals(Object)public Object get(Object key)
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.get in interface Mapkey - the key to look upNullPointerException - if this map does not accept null keyscontainsKey(Object)public int hashCode()
hashCode in interface MaphashCode in class ObjectMap.Entry.hashCode(),
Collection.hashCode()public boolean isEmpty()
size() == 0.public Set keySet()
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.
keySet in interface MapSet.iterator(),
size(),
containsKey(Object),
values()public Object put(Object key, Object value)
null values, a null return does not always
imply that the mapping was created.put in interface Mapkey - the key to mapvalue - the value to be mappedUnsupportedOperationException - if the operation is not supportedClassCastException - if the key or value is of the wrong typeIllegalArgumentException - if something about this key or value
prevents it from existing in this mapNullPointerException - if the map forbids null keys or valuescontainsKey(Object)public void putAll(Map m)
put,
so it is not supported if puts are not.putAll in interface Mapm - the mapping to load into this mapUnsupportedOperationException - if the operation is not supportedClassCastException - if a key or value is of the wrong typeIllegalArgumentException - if something about a key or value
prevents it from existing in this mapNullPointerException - if the map forbids null keys or values, or
if m is null.put(Object, Object)public Object remove(Object key)
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.remove in interface Mapkey - the key to removeUnsupportedOperationException - if deletion is unsupportedIterator.remove()public int size()
entrySet().size().size in interface MapCollection.size()public String toString()
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().public Collection values()
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.
values in interface MapCollection.iterator(),
size(),
containsValue(Object),
keySet()