public class WeakIdentityHashMap<K,V>
extends java.util.AbstractMap<K,V>
implements java.util.Map<K,V>
WeakHashMap and IdentityHashMap. The implementation is a modified version of WeakHashMap from JDK 1.5, which differs from the original in two ways:
IdentityHashMap for more information on the changes made in an identity
hash map.
The original documentation follows:
A hashtable-based Map implementation with weak keys. An entry in a
WeakIdentityHashMap will automatically be removed when its key is no longer in
ordinary use. More precisely, the presence of a mapping for a given key will not prevent the key
from being discarded by the garbage collector, that is, made finalizable, finalized, and then
reclaimed. When a key has been discarded its entry is effectively removed from the map, so this
class behaves somewhat differently than other Map implementations.
Both null values and the null key are supported. This class has performance characteristics
similar to those of the HashMap class, and has the same efficiency parameters of
initial capacity and load factor.
Like most collection classes, this class is not synchronized. A synchronized
WeakIdentityHashMap may be constructed using the Collections.synchronizedMap
method.
The behavior of the WeakIdentityHashMap class depends in part upon the actions of
the garbage collector, so several familiar (though not required) Map invariants do
not hold for this class. Because the garbage collector may discard keys at any time, a
WeakIdentityHashMap may behave as though an unknown thread is silently removing entries.
In particular, even if you synchronize on a WeakIdentityHashMap instance and invoke
none of its mutator methods, it is possible for the size method to return smaller
values over time, for the isEmpty method to return false and then
true, for the containsKey method to return true and later
false for a given key, for the get method to return a value for a given
key but later return null, for the put method to return null
and the remove method to return false for a key that previously
appeared to be in the map, and for successive examinations of the key set, the value set, and the
entry set to yield successively smaller numbers of elements.
Each key object in a WeakIdentityHashMap is stored indirectly as the referent of
a weak reference. Therefore a key will automatically be removed only after the weak references to
it, both inside and outside of the map, have been cleared by the garbage collector.
Implementation note: The value objects in a WeakIdentityHashMap
are held by ordinary strong references. Thus care should be taken to ensure that value objects do
not strongly refer to their own keys, either directly or indirectly, since that will prevent the
keys from being discarded. Note that a value object may refer indirectly to its key via the
WeakIdentityHashMap itself; that is, a value object may strongly refer to some other
key object whose associated value object, in turn, strongly refers to the key of the first value
object. One way to deal with this is to wrap values themselves within WeakReferences
before inserting, as in: m.put(key, new WeakReference(value)), and then unwrapping
upon each get.
The iterators returned by all of this class's "collection view methods" are fail-fast:
if the map is structurally modified at any time after the iterator is created, in any way except
through the iterator's own remove or add methods, the iterator will
throw a ConcurrentModificationException. Thus, in the face of concurrent
modification, the iterator fails quickly and cleanly, rather than risking arbitrary,
non-deterministic behavior at an undetermined time in the future.
Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally
speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent
modification. Fail-fast iterators throw ConcurrentModificationException on a
best-effort basis. Therefore, it would be wrong to write a program that depended on this
exception for its correctness: the fail-fast behavior of iterators should be used only to
detect bugs.
This class is a member of the Java Collections Framework.
HashMap,
WeakReference| Constructor and Description |
|---|
WeakIdentityHashMap()
Constructs a new, empty
WeakIdentityHashMap with the default initial capacity (16)
and the default load factor (0.75). |
WeakIdentityHashMap(int initialCapacity)
Constructs a new, empty
WeakIdentityHashMap with the given initial capacity and
the default load factor, which is 0.75. |
WeakIdentityHashMap(int initialCapacity,
float loadFactor)
Constructs a new, empty
WeakIdentityHashMap with the given initial capacity and
the given load factor. |
WeakIdentityHashMap(java.util.Map<? extends K,? extends V> t)
Constructs a new
WeakIdentityHashMap with the same mappings as the specified
Map. |
| Modifier and Type | Method and Description |
|---|---|
void |
clear()
Removes all mappings from this map.
|
boolean |
containsKey(@Nullable java.lang.Object key)
Returns
true if this map contains a mapping for the specified key. |
boolean |
containsValue(@Nullable java.lang.Object value)
Returns
true if this map maps one or more keys to the specified value. |
java.util.Set<java.util.Map.Entry<K,V>> |
entrySet()
Returns a collection view of the mappings contained in this map.
|
V |
get(@Nullable java.lang.Object key)
Returns the value to which the specified key is mapped in this weak hash map, or
null
if the map contains no mapping for this key. |
boolean |
isEmpty()
Returns
true if this map contains no key-value mappings. |
java.util.Set<K> |
keySet()
Returns a set view of the keys contained in this map.
|
V |
put(K key,
V value)
Associates the specified value with the specified key in this map.
|
void |
putAll(java.util.Map<? extends K,? extends V> m)
Copies all of the mappings from the specified map to this map These mappings will replace any
mappings that this map had for any of the keys currently in the specified map.
|
V |
remove(java.lang.Object key)
Removes the mapping for this key from this map if present.
|
int |
size()
Returns the number of key-value mappings in this map.
|
java.util.Collection<V> |
values()
Returns a collection view of the values contained in this map.
|
public WeakIdentityHashMap(int initialCapacity,
float loadFactor)
WeakIdentityHashMap with the given initial capacity and
the given load factor.initialCapacity - the initial capacity of the WeakIdentityHashMaploadFactor - the load factor of the WeakIdentityHashMapjava.lang.IllegalArgumentException - If the initial capacity is negative, or if the load factor is
nonpositivepublic WeakIdentityHashMap(int initialCapacity)
WeakIdentityHashMap with the given initial capacity and
the default load factor, which is 0.75.initialCapacity - the initial capacity of the WeakIdentityHashMapjava.lang.IllegalArgumentException - If the initial capacity is negativepublic WeakIdentityHashMap()
WeakIdentityHashMap with the default initial capacity (16)
and the default load factor (0.75).public WeakIdentityHashMap(java.util.Map<? extends K,? extends V> t)
WeakIdentityHashMap with the same mappings as the specified
Map. The WeakIdentityHashMap is created with default load factor,
which is 0.75 and an initial capacity sufficient to hold the mappings in the
specified Map.t - the map whose mappings are to be placed in this mapjava.lang.NullPointerException - if the specified map is null@Pure public int size()
@Pure public boolean isEmpty()
true if this map contains no key-value mappings. This result is a
snapshot, and may not reflect unprocessed entries that will be removed before next attempted
access because they are no longer referenced.@Pure public V get(@Nullable java.lang.Object key)
null
if the map contains no mapping for this key. A return value of null does
not necessarily indicate that the map contains no mapping for the key; it is also
possible that the map explicitly maps the key to null. The containsKey
method may be used to distinguish these two cases.get in interface java.util.Map<K,V>get in class java.util.AbstractMap<K,V>key - the key whose associated value is to be returnednull if the map
contains no mapping for this key.put(Object, Object)@Pure public boolean containsKey(@Nullable java.lang.Object key)
true if this map contains a mapping for the specified key.public V put(K key, V value)
put in interface java.util.Map<K,V>put in class java.util.AbstractMap<K,V>key - key with which the specified value is to be associatedvalue - value to be associated with the specified keynull if there was no
mapping for key. A null return can also indicate that the HashMap previously
associated null with the specified key.public void putAll(java.util.Map<? extends K,? extends V> m)
public V remove(java.lang.Object key)
remove in interface java.util.Map<K,V>remove in class java.util.AbstractMap<K,V>key - key whose mapping is to be removed from the mapnull if there was no
mapping for key. A null return can also indicate that the map previously
associated null with the specified key.public void clear()
@Pure public boolean containsValue(@Nullable java.lang.Object value)
true if this map maps one or more keys to the specified value.@SideEffectFree public java.util.Set<K> keySet()
Iterator.remove,
Set.remove, removeAll, retainAll, and clear
operations. It does not support the add or addAll operations.@SideEffectFree public java.util.Collection<V> values()
Iterator.remove, Collection.remove, removeAll, retainAll
, and clear operations. It does not support the add or
addAll operations.@SideEffectFree public java.util.Set<java.util.Map.Entry<K,V>> entrySet()
Map.Entry. The collection is backed by the map, so changes to the
map are reflected in the collection, and vice-versa. The collection supports element removal,
which removes the corresponding mapping from the map, via the Iterator.remove,
Collection.remove, removeAll, retainAll, and clear
operations. It does not support the add or addAll operations.