totalcross.util

Class IdentityHashMap4D<K,V>

java.lang.Object

totalcross.util.AbstractMap4D<K,V>

totalcross.util.IdentityHashMap4D<K,V>

All Implemented Interfaces:

java.lang.Cloneable, java.util.Map<K,V>

public class IdentityHashMap4D<K,V>
extends AbstractMap4D<K,V>
implements java.util.Map<K,V>, java.lang.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:

1.4

See Also:

System.identityHashCode(Object), Collection, Map, HashMap, TreeMap, LinkedHashMap, WeakHashMap

Nested Class Summary

Nested classes/interfaces inherited from class totalcross.util.AbstractMap4D

AbstractMap4D.SimpleEntry<K,V>, AbstractMap4D.SimpleImmutableEntry<K,V>

Nested classes/interfaces inherited from interface java.util.Map

java.util.Map.Entry<K,V>

Constructor Summary

Constructors

Constructor and Description
IdentityHashMap4D() Create a new IdentityHashMap with the default capacity (21 entries).
IdentityHashMap4D(int max) Create a new IdentityHashMap with the indicated number of entries.
IdentityHashMap4D(java.util.Map<? extends K,? extends V> m) Create a new IdentityHashMap whose contents are taken from the given Map.

Method Summary

Modifier and Type	Method and Description
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<java.util.Map.Entry<K,V>>	entrySet() Returns a "set view" of this Map's entries.
boolean	equals(java.lang.Object o) Compares two maps for equality.
V	get(java.lang.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
java.util.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(java.util.Map<? extends K,? extends V> m) Copies all of the mappings from the specified map to this.
V	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<V>	values() Returns a "collection view" (or "bag view") of this Map's values.

Methods inherited from class totalcross.util.AbstractMap4D

equals, hashCode, toString

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map

compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, putIfAbsent, remove, replace, replace, replaceAll

Constructor Detail

IdentityHashMap4D

public IdentityHashMap4D()

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

IdentityHashMap4D

public IdentityHashMap4D(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:

max - initial size

Throws:

java.lang.IllegalArgumentException - if max is negative

IdentityHashMap4D

public IdentityHashMap4D(java.util.Map<? extends K,? extends V> m)

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

Parameters:

m - The map whose elements are to be put in this map

Throws:

java.lang.NullPointerException - if m is null

Method Detail

clear

public void clear()

Remove all mappings from this map.

Specified by:

clear in interface java.util.Map<K,V>

Overrides:

clear in class AbstractMap4D<K,V>

See Also:

Set.clear()

clone

public java.lang.Object clone()

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

Overrides:

clone in class AbstractMap4D<K,V>

Returns:

the shallow clone

See Also:

Cloneable, Object.clone()

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

Specified by:

containsKey in interface java.util.Map<K,V>

Overrides:

containsKey in class AbstractMap4D<K,V>

Parameters:

key - the key to look for

Returns:

true if the key is contained in the map

See Also:

containsValue(Object), get(Object)

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

Specified by:

containsValue in interface java.util.Map<K,V>

Overrides:

containsValue in class AbstractMap4D<K,V>

Parameters:

value - the value to search for in this HashMap

Returns:

true if at least one key maps to the value

See Also:

containsKey(Object)

entrySet

public java.util.Set<java.util.Map.Entry<K,V>> 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.

Specified by:

entrySet in interface java.util.Map<K,V>

Specified by:

entrySet in class AbstractMap4D<K,V>

Returns:

a set view of the entries

See Also:

keySet(), values(), Map.Entry

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.

Specified by:

equals in interface java.util.Map<K,V>

Overrides:

equals in class AbstractMap4D<K,V>

Parameters:

o - the object to compare to

Returns:

true if it is equal

See Also:

Set.equals(Object)

get

public V 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).

Specified by:

get in interface java.util.Map<K,V>

Overrides:

get in class AbstractMap4D<K,V>

Parameters:

key - the key for which to fetch an associated value

Returns:

what the key maps to, if present

See Also:

put(Object, Object), containsKey(Object)

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

Specified by:

hashCode in interface java.util.Map<K,V>

Overrides:

hashCode in class AbstractMap4D<K,V>

Returns:

the hash code

See Also:

Map.Entry#hashCode(), Set.hashCode()

isEmpty

public boolean isEmpty()

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

Specified by:

isEmpty in interface java.util.Map<K,V>

Overrides:

isEmpty in class AbstractMap4D<K,V>

Returns:

size() == 0

See Also:

AbstractMap4D.size()

keySet

public java.util.Set<K> 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.

Specified by:

keySet in interface java.util.Map<K,V>

Overrides:

keySet in class AbstractMap4D<K,V>

Returns:

a set view of the keys

See Also:

values(), entrySet()

put

public V put(K key,
             V 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).

Specified by:

put in interface java.util.Map<K,V>

Overrides:

put in class AbstractMap4D<K,V>

Parameters:

key - the key used to locate the value

value - the value to be stored in the HashMap

Returns:

the prior mapping of the key, or null if there was none

See Also:

get(Object)

putAll

public void putAll(java.util.Map<? extends K,? extends V> m)

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

Specified by:

putAll in interface java.util.Map<K,V>

Overrides:

putAll in class AbstractMap4D<K,V>

Parameters:

m - the map to copy

Throws:

java.lang.NullPointerException - if m is null

See Also:

AbstractMap4D.put(Object, Object)

remove

public V 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).

Specified by:

remove in interface java.util.Map<K,V>

Overrides:

remove in class AbstractMap4D<K,V>

Parameters:

key - the key used to locate the value to remove

Returns:

whatever the key mapped to, if present

See Also:

Iterator.remove()

size

public int size()

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

Specified by:

size in interface java.util.Map<K,V>

Overrides:

size in class AbstractMap4D<K,V>

Returns:

the size

See Also:

Set.size()

values

public java.util.Collection<V> 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().

Specified by:

values in interface java.util.Map<K,V>

Overrides:

values in class AbstractMap4D<K,V>

Returns:

a bag view of the values

See Also:

keySet(), entrySet()