|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectjava.util.AbstractMap<K,V>
com.google.common.collect.ReferenceMap<K,V>
public final class ReferenceMap<K,V>
A ConcurrentMap implementation that internally utilizes your choice
of strong, soft or weak references for its keys and for its values. As soon
as any key or value is reclaimed by the garbage collector, the corresponding
entry automatically disappears from the map.
All nine possible combinations of reference types are supported, although
using strong keys with strong values provides no benefit over using a Map or ConcurrentMap directly.
Note: because garbage collection happens concurrently to your
program, it follows that this map is always subject to concurrent
modifications, whether or not the caller exposes it to multiple application
threads. The usual caveats about the reliability of methods such as size() and Map.equals(java.lang.Object) apply; for example, size() may be
observed to remain unchanged for a short time after an entry was reclaimed.
This implementation does not permit null keys or values. To determine
equality to a key or value, this implementation uses Object.equals(java.lang.Object)
for strong references, and identity-based equality for soft and weak
references.
Note: new ReferenceMap(WEAK, STRONG) is very nearly a
drop-in replacement for WeakHashMap, but improves upon this by using
only identity-based equality for keys. When possible, ReferenceMap
should be preferred over the JDK collection, for its concurrency and greater
flexibility.
Though this class implements Serializable, serializing reference
maps with weak or soft references leads to unpredictable results.
| Nested Class Summary |
|---|
| Nested classes/interfaces inherited from interface java.util.Map |
|---|
java.util.Map.Entry<K,V> |
| Constructor Summary | |
|---|---|
ReferenceMap(ReferenceType keyReferenceType,
ReferenceType valueReferenceType)
Constructs an empty instance, using the given reference types for keys and values. |
|
ReferenceMap(ReferenceType keyReferenceType,
ReferenceType valueReferenceType,
java.util.concurrent.ConcurrentMap<java.lang.Object,java.lang.Object> backingMap)
Constructs an empty instance, using the given backing map and the given reference types for keys and values. |
|
| Method Summary | |
|---|---|
void |
clear()
|
boolean |
containsKey(java.lang.Object key)
|
boolean |
containsValue(java.lang.Object value)
|
java.util.Set<java.util.Map.Entry<K,V>> |
entrySet()
|
V |
get(java.lang.Object key)
|
boolean |
isEmpty()
|
V |
put(K key,
V value)
|
V |
putIfAbsent(K key,
V value)
|
V |
remove(java.lang.Object key)
|
boolean |
remove(java.lang.Object key,
java.lang.Object value)
|
V |
replace(K key,
V value)
|
boolean |
replace(K key,
V oldValue,
V newValue)
|
int |
size()
|
| Methods inherited from class java.util.AbstractMap |
|---|
clone, equals, hashCode, keySet, putAll, toString, values |
| Methods inherited from class java.lang.Object |
|---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
| Methods inherited from interface java.util.Map |
|---|
equals, hashCode, keySet, putAll, values |
| Constructor Detail |
|---|
public ReferenceMap(ReferenceType keyReferenceType,
ReferenceType valueReferenceType)
public ReferenceMap(ReferenceType keyReferenceType,
ReferenceType valueReferenceType,
java.util.concurrent.ConcurrentMap<java.lang.Object,java.lang.Object> backingMap)
| Method Detail |
|---|
public int size()
size in interface java.util.Map<K,V>size in class java.util.AbstractMap<K,V>public boolean isEmpty()
isEmpty in interface java.util.Map<K,V>isEmpty in class java.util.AbstractMap<K,V>public boolean containsKey(java.lang.Object key)
containsKey in interface java.util.Map<K,V>containsKey in class java.util.AbstractMap<K,V>public boolean containsValue(java.lang.Object value)
containsValue in interface java.util.Map<K,V>containsValue in class java.util.AbstractMap<K,V>public V get(java.lang.Object key)
get in interface java.util.Map<K,V>get in class java.util.AbstractMap<K,V>
public V put(K key,
V value)
put in interface java.util.Map<K,V>put in class java.util.AbstractMap<K,V>
public V putIfAbsent(K key,
V value)
putIfAbsent in interface java.util.concurrent.ConcurrentMap<K,V>
public V replace(K key,
V value)
replace in interface java.util.concurrent.ConcurrentMap<K,V>
public boolean replace(K key,
V oldValue,
V newValue)
replace in interface java.util.concurrent.ConcurrentMap<K,V>public V remove(java.lang.Object key)
remove in interface java.util.Map<K,V>remove in class java.util.AbstractMap<K,V>
public boolean remove(java.lang.Object key,
java.lang.Object value)
remove in interface java.util.concurrent.ConcurrentMap<K,V>public void clear()
clear in interface java.util.Map<K,V>clear in class java.util.AbstractMap<K,V>public java.util.Set<java.util.Map.Entry<K,V>> entrySet()
Note: Regardless of the choice of key and value reference types, an entry in the entry set always has strong references to both key and value. You should avoid any lingering strong references to Entry objects.
entrySet in interface java.util.Map<K,V>entrySet in class java.util.AbstractMap<K,V>
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||