|
Keel 2.1RC2 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||||
java.lang.Objectjava.util.AbstractMap
org.apache.commons.collections.ReferenceMap
Hashtable-based Map implementation that allows mappings to be removed by the garbage collector.
When you construct a ReferenceMap, you can specify what kind of references are used to store the map's keys and values. If non-hard references are used, then the garbage collector can remove mappings if a key or value becomes unreachable, or if the JVM's memory is running low. For information on how the different reference types behave, see Reference.
Different types of references can be specified for keys and values. The keys can be configured to be weak but the values hard, in which case this class will behave like a . However, you can also specify hard keys and weak values, or any other combination. The default constructor uses hard keys and soft values, providing a memory-sensitive cache.
The algorithms used are basically the same as those in HashMap. In particular, you can specify a load factor and capacity to suit your needs. All optional Map operations are supported.
However, this Map implementation does not allow null elements. Attempting to add a null key or or a null value to the map will raise a NullPointerException.
As usual, this implementation is not synchronized. You can use Collections.synchronizedMap(java.util.Map) to provide synchronized access to a ReferenceMap.
Reference| Nested Class Summary | |
private class |
ReferenceMap.Entry |
private class |
ReferenceMap.EntryIterator |
private class |
ReferenceMap.KeyIterator |
private static class |
ReferenceMap.SoftRef |
private class |
ReferenceMap.ValueIterator |
private static class |
ReferenceMap.WeakRef |
| Nested classes inherited from class java.util.AbstractMap |
|
| Field Summary | |
private java.util.Set |
entrySetCached entry set. |
static int |
HARDConstant indicating that hard references should be used. |
private java.util.Set |
keySetCached key set. |
private int |
keyTypeThe reference type for keys. |
private float |
loadFactorThe threshold variable is calculated by multiplying table.length and loadFactor. |
private int |
modCountNumber of times this map has been modified. |
private java.lang.ref.ReferenceQueue |
queueReferenceQueue used to eliminate stale mappings. |
private static long |
serialVersionUIDFor serialization. |
private int |
sizeNumber of mappings in this map. |
static int |
SOFTConstant indiciating that soft references should be used. |
private ReferenceMap.Entry[] |
tableThe hash table. |
private int |
thresholdWhen size reaches threshold, the map is resized. |
private java.util.Collection |
valuesCached values. |
private int |
valueTypeThe reference type for values. |
static int |
WEAKConstant indicating that weak references should be used. |
| Constructor Summary | |
ReferenceMap()Constructs a new ReferenceMap that will use hard references to keys and soft references to values. |
|
ReferenceMap(int keyType, int valueType)Constructs a new ReferenceMap that will use the specified types of references. |
|
ReferenceMap(int keyType, int valueType, int capacity, float loadFactor)Constructs a new ReferenceMap with the specified reference types, load factor and initial capacity. |
|
| Method Summary | |
void |
clear()Clears this map. |
boolean |
containsKey(java.lang.Object key)Returns true if this map contains the given key. |
java.util.Set |
entrySet()Returns a set view of this map's entries. |
java.lang.Object |
get(java.lang.Object key)Returns the value associated with the given key, if any. |
private ReferenceMap.Entry |
getEntry(java.lang.Object key)Returns the entry associated with the given key. |
private int |
indexFor(int hash)Converts the given hash code into an index into the hash table. |
boolean |
isEmpty()Returns true if this map is empty. |
java.util.Set |
keySet()Returns a set view of this map's keys. |
private void |
purge()Purges stale mappings from this map. |
private void |
purge(java.lang.ref.Reference ref) |
java.lang.Object |
put(java.lang.Object key, java.lang.Object value)Associates the given key with the given value. |
private void |
readObject(java.io.ObjectInputStream inp)Reads the contents of this object from the given input stream. |
java.lang.Object |
remove(java.lang.Object key)Removes the key and its associated value from this map. |
private void |
resize()Resizes this hash table by doubling its capacity. |
int |
size()Returns the size of this map. |
private java.lang.Object |
toReference(int type, java.lang.Object referent, int hash)Constructs a reference of the given type to the given referent. |
java.util.Collection |
values()Returns a collection view of this map's values. |
private static void |
verify(java.lang.String name, int type) |
private void |
writeObject(java.io.ObjectOutputStream out)Writes this object to the given output stream. |
| Methods inherited from class java.util.AbstractMap |
clone, containsValue, equals, hashCode, putAll, toString |
| Methods inherited from class java.lang.Object |
finalize, getClass, notify, notifyAll, wait, wait, wait |
| Field Detail |
private static final long serialVersionUID
public static final int HARD
public static final int SOFT
public static final int WEAK
private int keyType
private int valueType
private float loadFactor
private transient java.lang.ref.ReferenceQueue queue
purge()private transient ReferenceMap.Entry[] table
private transient int size
private transient int threshold
resizeprivate transient volatile int modCount
private transient java.util.Set keySet
private transient java.util.Set entrySet
private transient java.util.Collection values
| Constructor Detail |
public ReferenceMap()
ReferenceMap that will use hard references to keys and soft references to values.
public ReferenceMap(int keyType,
int valueType)
ReferenceMap that will use the specified types of references.
keyType - the type of reference to use for keys; must be HARD, SOFT, WEAKvalueType - the type of reference to use for values; must be HARD, SOFT, WEAK
public ReferenceMap(int keyType,
int valueType,
int capacity,
float loadFactor)
ReferenceMap with the specified reference types, load factor and initial capacity.
keyType - the type of reference to use for keys; must be HARD, SOFT, WEAKvalueType - the type of reference to use for values; must be HARD, SOFT, WEAKcapacity - the initial capacity for the maploadFactor - the load factor for the map| Method Detail |
private static void verify(java.lang.String name,
int type)
private void writeObject(java.io.ObjectOutputStream out)
throws java.io.IOException
out - the output stream to write tojava.io.IOException - if the stream raises it
private void readObject(java.io.ObjectInputStream inp)
throws java.io.IOException,
java.lang.ClassNotFoundException
inp - the input stream to read fromjava.io.IOException - if the stream raises itjava.lang.ClassNotFoundException - if the stream raises it
private java.lang.Object toReference(int type,
java.lang.Object referent,
int hash)
type - HARD, SOFT or WEAKreferent - the object to refer tohash - the hash code of the key of the mapping; this number might be different from referent.hashCode() if the referent represents a value and not a keyprivate ReferenceMap.Entry getEntry(java.lang.Object key)
key - the key of the entry to look upprivate int indexFor(int hash)
private void resize()
private void purge()
Ordinarily, stale mappings are only removed during a write operation; typically a write operation will occur often enough that you'll never need to manually invoke this method.
Note that this method is not synchronized! Special care must be taken if, for instance, you want stale mappings to be removed on a periodic basis by some background thread.
private void purge(java.lang.ref.Reference ref)
public int size()
public boolean isEmpty()
true if this map is empty.
true if this map is emptypublic boolean containsKey(java.lang.Object key)
true if this map contains the given key.
public java.lang.Object get(java.lang.Object key)
null if the key maps to no value
public java.lang.Object put(java.lang.Object key,
java.lang.Object value)
Neither the key nor the value may be null.
key - the key of the mappingvalue - the value of the mappingjava.lang.NullPointerException - if either the key or value is nullpublic java.lang.Object remove(java.lang.Object key)
key - the key to removepublic void clear()
public java.util.Set entrySet()
public java.util.Set keySet()
public java.util.Collection values()
|
Keel 2.1RC2 | ||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||||