java.lang.Object | +--java.util.AbstractMap | +--java.util.IdentityHashMapAll Implemented Interfaces:
IdentityHashMap() Create a new IdentityHashMap with the default capacity (21 entries). |
IdentityHashMap(int max) Create a new IdentityHashMap with the indicated number of entries. |
IdentityHashMap(java.util.Map m) Create a new IdentityHashMap whose contents are taken from the given Map. |
void | clear() Remove all mappings from this map. |
java.lang.Object | clone() Creates a shallow copy where keys and values are not cloned. |
boolean | containsKey(java.lang.Object key) Tests whether the specified key is in this map. |
boolean | containsValue(java.lang.Object value) Returns true if this HashMap contains the value. |
java.util.Set | entrySet() Returns a "set view" of this Map's entries. |
boolean | equals(java.lang.Object o) Compares two maps for equality. |
java.lang.Object | get(java.lang.Object key) Return the value in this Map associated with the supplied key, or
|
int | hashCode() Returns the hashcode of this map. |
boolean | isEmpty() Returns true if there are no key-value mappings currently in this Map |
java.util.Set | keySet() Returns a "set view" of this Map's keys. |
java.lang.Object | put(java.lang.Object key, java.lang.Object value) Puts the supplied value into the Map, mapped by the supplied key. |
void | putAll(java.util.Map m) Copies all of the mappings from the specified map to this. |
java.lang.Object | remove(java.lang.Object key) Removes from the HashMap and returns the value which is mapped by the supplied key. |
int | size() Returns the number of kay-value mappings currently in this Map |
java.util.Collection | values() Returns a "collection view" (or "bag view") of this Map's values. |
public IdentityHashMap()
public IdentityHashMap(int max)
max
- initial sizeIllegalArgumentException
- if max is negativepublic IdentityHashMap(java.util.Map m)
m
- The map whose elements are to be put in this mapNullPointerException
- if m is nullpublic void clear()
public Object clone()
public boolean containsKey(java.lang.Object key)
entry == key
instead of
entry == null ? key == null : entry.equals(key)
.
key
- the key to look forpublic boolean containsValue(java.lang.Object value)
entry == value
instead of
entry == null ? value == null : entry.equals(value)
.
value
- the value to search for in this HashMappublic Set entrySet()
The semantics of this set, and of its contained entries, are
different from the contract of Set and Map.Entry in order to make
IdentityHashMap work. This means that while you can compare these
objects between IdentityHashMaps, comparing them with regular sets
or entries is likely to have undefined behavior. The entries
in this set are reference-based, rather than the normal object
equality. Therefore, e1.equals(e2)
returns
e1.getKey() == e2.getKey() && e1.getValue() == e2.getValue()
,
and e.hashCode()
returns
System.identityHashCode(e.getKey()) ^
System.identityHashCode(e.getValue())
.
Note that the iterators for all three views, from keySet(), entrySet(), and values(), traverse the Map in the same sequence.
public boolean equals(java.lang.Object o)
this.entrySet().equals(m.entrySet())
as specified by Map,
this will not work with normal maps, since the entry set compares
with == instead of .equals.
o
- the object to compare topublic Object get(java.lang.Object key)
null
if the key maps to nothing.
NOTE: Since the value could also be null, you must use
containsKey to see if this key actually maps to something.
Unlike normal maps, this tests for the key with entry ==
key
instead of entry == null ? key == null :
entry.equals(key)
.
key
- the key for which to fetch an associated valuepublic int hashCode()
public boolean isEmpty()
size() == 0
public Set keySet()
The semantics of this set are different from the contract of Set in order to make IdentityHashMap work. This means that while you can compare these objects between IdentityHashMaps, comparing them with regular sets is likely to have undefined behavior. The hashCode of the set is the sum of the identity hash codes, instead of the regular hashCodes, and equality is determined by reference instead of by the equals method.
public Object put(java.lang.Object key, java.lang.Object value)
equals()
this key. NOTE: Since the prior value could also be null, you must
first use containsKey if you want to see if you are replacing the
key's mapping. Unlike normal maps, this tests for the key
with entry == key
instead of
entry == null ? key == null : entry.equals(key)
.
key
- the key used to locate the valuevalue
- the value to be stored in the HashMappublic void putAll(java.util.Map m)
m
- the map to copyNullPointerException
- if m is nullpublic Object remove(java.lang.Object key)
null
is returned.
NOTE: Since the value could also be null, you must use
containsKey to see if you are actually removing a mapping.
Unlike normal maps, this tests for the key with entry ==
key
instead of entry == null ? key == null :
entry.equals(key)
.
key
- the key used to locate the value to removepublic int size()
public Collection values()
The semantics of this set are different from the contract of Collection in order to make IdentityHashMap work. This means that while you can compare these objects between IdentityHashMaps, comparing them with regular sets is likely to have undefined behavior. Likewise, contains and remove go by == instead of equals().
WARNING: This is not a general purpose map. Because it uses System.identityHashCode and ==, instead of hashCode and equals, for comparison, it violated Map's general contract, and may cause undefined behavior when compared to other maps which are not IdentityHashMaps. This is designed only for the rare cases when identity semantics are needed. An example use is topology-preserving graph transformations, such as deep cloning, or as proxy object mapping such as in debugging.
This map permits
null
keys and values, and does not guarantee that elements will stay in the same order over time. The basic operations (get
andput
) take constant time, provided System.identityHashCode is decent. You can tune the behavior by specifying the expected maximum size. As more elements are added, the map may need to allocate a larger table, which can be expensive.This implementation is unsynchronized. If you want multi-thread access to be consistent, you must synchronize it, perhaps by using
Collections.synchronizedMap(new IdentityHashMap(...));
. The iterators are fail-fast, meaning that a structural modification made to the map outside of an iterator's remove method cause the iterator, and in the case of the entrySet, the Map.Entry, to fail with a ConcurrentModificationException.