|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectjava.util.AbstractMap<K,V>
java.util.IdentityHashMap<K,V>
public class IdentityHashMap<K,V>
This class provides a hashtable-backed implementation of the Map interface, but uses object identity to do its hashing. In fact, it uses object identity for comparing values, as well. It uses a linear-probe hash table, which may have faster performance than the chaining employed by HashMap.
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
and put
) 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
.
System.identityHashCode(Object)
,
Collection
,
Map
,
HashMap
,
TreeMap
,
LinkedHashMap
,
WeakHashMap
,
Serialized FormNested Class Summary |
---|
Nested classes/interfaces inherited from class java.util.AbstractMap |
---|
AbstractMap.SimpleEntry<K,V>, AbstractMap.SimpleImmutableEntry<K,V> |
Nested classes/interfaces inherited from interface java.util.Map |
---|
Map.Entry<K,V> |
Constructor Summary | |
---|---|
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(Map<? extends K,? extends V> m)
Create a new IdentityHashMap whose contents are taken from the given Map. |
Method Summary | |
---|---|
void |
clear()
Remove all mappings from this map. |
Object |
clone()
Creates a shallow copy where keys and values are not cloned. |
boolean |
containsKey(Object key)
Tests whether the specified key is in this map. |
boolean |
containsValue(Object value)
Returns true if this HashMap contains the value. |
Set<Map.Entry<K,V>> |
entrySet()
Returns a "set view" of this Map's entries. |
boolean |
equals(Object o)
Compares two maps for equality. |
V |
get(Object key)
Return the value in this Map associated with the supplied key, or null if the key maps to nothing. |
int |
hashCode()
Returns the hashcode of this map. |
boolean |
isEmpty()
Returns true if there are no key-value mappings currently in this Map |
Set<K> |
keySet()
Returns a "set view" of this Map's keys. |
V |
put(K key,
V value)
Puts the supplied value into the Map, mapped by the supplied key. |
void |
putAll(Map<? extends K,? extends V> m)
Copies all of the mappings from the specified map to this. |
V |
remove(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 |
Collection<V> |
values()
Returns a "collection view" (or "bag view") of this Map's values. |
Methods inherited from class java.util.AbstractMap |
---|
toString |
Methods inherited from class java.lang.Object |
---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
Constructor Detail |
---|
public IdentityHashMap()
public IdentityHashMap(int max)
max
- initial size
IllegalArgumentException
- if max is negativepublic IdentityHashMap(Map<? extends K,? extends V> m)
m
- The map whose elements are to be put in this map
NullPointerException
- if m is nullMethod Detail |
---|
public void clear()
clear
in interface Map<K,V>
clear
in class AbstractMap<K,V>
Set.clear()
public Object clone()
clone
in class AbstractMap<K,V>
Cloneable
,
Object.clone()
public boolean containsKey(Object key)
entry == key
instead of
entry == null ? key == null : entry.equals(key)
.
containsKey
in interface Map<K,V>
containsKey
in class AbstractMap<K,V>
key
- the key to look for
containsValue(Object)
,
get(Object)
public boolean containsValue(Object value)
entry == value
instead of
entry == null ? value == null : entry.equals(value)
.
containsValue
in interface Map<K,V>
containsValue
in class AbstractMap<K,V>
value
- the value to search for in this HashMap
containsKey(Object)
public Set<Map.Entry<K,V>> 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.
entrySet
in interface Map<K,V>
entrySet
in class AbstractMap<K,V>
keySet()
,
values()
,
Map.Entry
public boolean equals(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.
equals
in interface Map<K,V>
equals
in class AbstractMap<K,V>
o
- the object to compare to
Set.equals(Object)
public V get(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)
.
get
in interface Map<K,V>
get
in class AbstractMap<K,V>
key
- the key for which to fetch an associated value
put(Object, Object)
,
containsKey(Object)
public int hashCode()
hashCode
in interface Map<K,V>
hashCode
in class AbstractMap<K,V>
Map.Entry.hashCode()
,
Set.hashCode()
public boolean isEmpty()
isEmpty
in interface Map<K,V>
isEmpty
in class AbstractMap<K,V>
size() == 0
AbstractMap.size()
public Set<K> 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.
keySet
in interface Map<K,V>
keySet
in class AbstractMap<K,V>
values()
,
entrySet()
public V put(K key, V 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)
.
put
in interface Map<K,V>
put
in class AbstractMap<K,V>
key
- the key used to locate the valuevalue
- the value to be stored in the HashMap
get(Object)
public void putAll(Map<? extends K,? extends V> m)
putAll
in interface Map<K,V>
putAll
in class AbstractMap<K,V>
m
- the map to copy
NullPointerException
- if m is nullAbstractMap.put(Object, Object)
public V remove(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)
.
remove
in interface Map<K,V>
remove
in class AbstractMap<K,V>
key
- the key used to locate the value to remove
Iterator.remove()
public int size()
size
in interface Map<K,V>
size
in class AbstractMap<K,V>
Set.size()
public Collection<V> 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().
values
in interface Map<K,V>
values
in class AbstractMap<K,V>
keySet()
,
entrySet()
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |