Index (Frames) | Index (No Frames) | Package | Package Tree | Tree
java.util

Class IdentityHashMap

java.lang.Object
|
+--java.util.AbstractMap
   |
   +--java.util.IdentityHashMap

All Implemented Interfaces:

Map, Serializable, Cloneable, Map


public class IdentityHashMap

extends AbstractMap

implements Map, Serializable, Cloneable

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.

Since:Authors:See Also:

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(java.util.Map m)

Create a new IdentityHashMap whose contents are taken from the given Map.

Method Summary

voidclear()

Remove all mappings from this map.
java.lang.Objectclone()

Creates a shallow copy where keys and values are not cloned.
booleancontainsKey(java.lang.Object key)

Tests whether the specified key is in this map.
booleancontainsValue(java.lang.Object value)

Returns true if this HashMap contains the value.
java.util.SetentrySet()

Returns a "set view" of this Map's entries.
booleanequals(java.lang.Object o)

Compares two maps for equality.
java.lang.Objectget(java.lang.Object key)

Return the value in this Map associated with the supplied key, or null if the key maps to nothing.
inthashCode()

Returns the hashcode of this map.
booleanisEmpty()

Returns true if there are no key-value mappings currently in this Map
java.util.SetkeySet()

Returns a "set view" of this Map's keys.
java.lang.Objectput(java.lang.Object key, java.lang.Object value)

Puts the supplied value into the Map, mapped by the supplied key.
voidputAll(java.util.Map m)

Copies all of the mappings from the specified map to this.
java.lang.Objectremove(java.lang.Object key)

Removes from the HashMap and returns the value which is mapped by the supplied key.
intsize()

Returns the number of kay-value mappings currently in this Map
java.util.Collectionvalues()

Returns a "collection view" (or "bag view") of this Map's values.

Constructor Details

IdentityHashMap

public IdentityHashMap()

Create a new IdentityHashMap with the default capacity (21 entries).


IdentityHashMap

public IdentityHashMap(int max)

Create a new IdentityHashMap with the indicated number of entries. If the number of elements added to this hash map exceeds this maximum, the map will grow itself; however, that incurs a performance penalty.

Parameters:

Throws:


IdentityHashMap

public IdentityHashMap(java.util.Map m)

Create a new IdentityHashMap whose contents are taken from the given Map.

Parameters:

Throws:


Method Details

clear

public void clear()

Remove all mappings from this map.


clone

public Object clone()

Creates a shallow copy where keys and values are not cloned.


containsKey

public boolean containsKey(java.lang.Object key)

Tests whether the specified key is in this map. Unlike normal Maps, this test uses entry == key instead of entry == null ? key == null : entry.equals(key).

Parameters:

Returns:

See Also:


containsValue

public boolean containsValue(java.lang.Object value)

Returns true if this HashMap contains the value. Unlike normal maps, this test uses entry == value instead of entry == null ? value == null : entry.equals(value).

Parameters:

Returns:

See Also:


entrySet

public Set entrySet()

Returns a "set view" of this Map's entries. The set is backed by the Map, so changes in one show up in the other. The set supports element removal, but not element addition.

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.

Returns:

See Also:


equals

public boolean equals(java.lang.Object o)

Compares two maps for equality. This returns true only if both maps have the same reference-identity comparisons. While this returns 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.

Parameters:

Returns:


get

public Object get(java.lang.Object key)

Return the value in this Map associated with the supplied key, or 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).

Parameters:

Returns:

See Also:


hashCode

public int hashCode()

Returns the hashcode of this map. This guarantees that two IdentityHashMaps that compare with equals() will have the same hash code, but may break with comparison to normal maps since it uses System.identityHashCode() instead of hashCode().

Returns:


isEmpty

public boolean isEmpty()

Returns true if there are no key-value mappings currently in this Map

Returns:


keySet

public Set keySet()

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. The set supports element removal, but not element addition.

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.

Returns:

See Also:


put

public Object put(java.lang.Object key, java.lang.Object value)

Puts the supplied value into the Map, mapped by the supplied key. The value may be retrieved by any object which 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).

Parameters:

Returns:

See Also:


putAll

public void putAll(java.util.Map m)

Copies all of the mappings from the specified map to this. If a key is already in this map, its value is replaced.

Parameters:

Throws:


remove

public Object remove(java.lang.Object key)

Removes from the HashMap and returns the value which is mapped by the supplied key. If the key maps to nothing, then the HashMap remains unchanged, and 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).

Parameters:

Returns:


size

public int size()

Returns the number of kay-value mappings currently in this Map

Returns:


values

public Collection values()

Returns a "collection view" (or "bag view") of this Map's values. The collection is backed by the Map, so changes in one show up in the other. The collection supports element removal, but not element addition.

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().

Returns:

See Also: