public abstract class AbstractReferenceMap extends AbstractHashedMap
This class implements all the features necessary for a subclass reference
hash-based map. Key-value entries are stored in instances of the
ReferenceEntry class which can be overridden and replaced.
The iterators can similarly be replaced, without the need to replace the KeySet,
EntrySet and Values view classes.
Overridable methods are provided to change the default hashing behaviour, and to change how entries are added to and removed from the map. Hopefully, all you need for unusual subclasses is here.
When you construct an AbstractReferenceMap, 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
WeakHashMap. 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.
This Map implementation does not allow null elements.
Attempting to add a null key or value to the map will raise a
NullPointerException.
All the available iterators can be reset back to the start by casting to
ResettableIterator and calling reset().
This implementation is not synchronized.
You can use Collections.synchronizedMap(java.util.Map) to
provide synchronized access to a ReferenceMap.
Reference| Modifier and Type | Class and Description |
|---|---|
protected static class |
AbstractReferenceMap.ReferenceEntry
A MapEntry implementation for the map.
|
AbstractHashedMap.EntrySet, AbstractHashedMap.EntrySetIterator, AbstractHashedMap.HashEntry, AbstractHashedMap.HashIterator, AbstractHashedMap.HashMapIterator, AbstractHashedMap.KeySet, AbstractHashedMap.KeySetIterator, AbstractHashedMap.Values, AbstractHashedMap.ValuesIteratorAbstractMap.SimpleEntry, AbstractMap.SimpleImmutableEntry| Modifier and Type | Field and Description |
|---|---|
static int |
HARD
Constant indicating that hard references should be used
|
protected int |
keyType
The reference type for keys.
|
protected boolean |
purgeValues
Should the value be automatically purged when the associated key has been collected?
|
static int |
SOFT
Constant indicating that soft references should be used
|
protected int |
valueType
The reference type for values.
|
static int |
WEAK
Constant indicating that weak references should be used
|
data, DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_THRESHOLD, entrySet, GETKEY_INVALID, GETVALUE_INVALID, keySet, loadFactor, MAXIMUM_CAPACITY, modCount, NO_NEXT_ENTRY, NO_PREVIOUS_ENTRY, NULL, REMOVE_INVALID, SETVALUE_INVALID, size, threshold, values| Modifier | Constructor and Description |
|---|---|
protected |
AbstractReferenceMap()
Constructor used during deserialization.
|
protected |
AbstractReferenceMap(int keyType,
int valueType,
int capacity,
float loadFactor,
boolean purgeValues)
Constructs a new empty map with the specified reference types,
load factor and initial capacity.
|
| Modifier and Type | Method and Description |
|---|---|
void |
clear()
Clears this map.
|
boolean |
containsKey(Object key)
Checks whether the map contains the specified key.
|
boolean |
containsValue(Object value)
Checks whether the map contains the specified value.
|
protected AbstractHashedMap.HashEntry |
createEntry(AbstractHashedMap.HashEntry next,
int hashCode,
Object key,
Object value)
Creates a ReferenceEntry instead of a HashEntry.
|
protected Iterator |
createEntrySetIterator()
Creates an entry set iterator.
|
protected Iterator |
createKeySetIterator()
Creates an key set iterator.
|
protected Iterator |
createValuesIterator()
Creates an values iterator.
|
protected void |
doReadObject(ObjectInputStream in)
Replaces the superclassm method to read the state of this class.
|
protected void |
doWriteObject(ObjectOutputStream out)
Replaces the superclass method to store the state of this class.
|
Set |
entrySet()
Returns a set view of this map's entries.
|
Object |
get(Object key)
Gets the value mapped to the key specified.
|
protected AbstractHashedMap.HashEntry |
getEntry(Object key)
Gets the entry mapped to the key specified.
|
protected int |
hashEntry(Object key,
Object value)
Gets the hash code for a MapEntry.
|
protected void |
init()
Initialise this subclass during construction, cloning or deserialization.
|
boolean |
isEmpty()
Checks whether the map is currently empty.
|
protected boolean |
isEqualKey(Object key1,
Object key2)
Compares two keys, in internal converted form, to see if they are equal.
|
Set |
keySet()
Returns a set view of this map's keys.
|
MapIterator |
mapIterator()
Gets a MapIterator over the reference map.
|
protected void |
purge()
Purges stale mappings from this map.
|
protected void |
purge(Reference ref)
Purges the specified reference.
|
protected void |
purgeBeforeRead()
Purges stale mappings from this map before read operations.
|
protected void |
purgeBeforeWrite()
Purges stale mappings from this map before write operations.
|
Object |
put(Object key,
Object value)
Puts a key-value mapping into this map.
|
Object |
remove(Object key)
Removes the specified mapping from this map.
|
int |
size()
Gets the size of the map.
|
Collection |
values()
Returns a collection view of this map's values.
|
addEntry, addMapping, calculateNewCapacity, calculateThreshold, checkCapacity, clone, convertKey, destroyEntry, ensureCapacity, entryHashCode, entryKey, entryNext, entryValue, equals, hash, hashCode, hashIndex, isEqualValue, putAll, removeEntry, removeMapping, reuseEntry, toString, updateEntrypublic static final int HARD
public static final int SOFT
public static final int WEAK
protected int keyType
protected int valueType
protected boolean purgeValues
protected AbstractReferenceMap()
protected AbstractReferenceMap(int keyType,
int valueType,
int capacity,
float loadFactor,
boolean purgeValues)
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 mappurgeValues - should the value be automatically purged when the
key is garbage collectedprotected void init()
init in class AbstractHashedMappublic int size()
size in interface Mapsize in class AbstractHashedMappublic boolean isEmpty()
isEmpty in interface MapisEmpty in class AbstractHashedMappublic boolean containsKey(Object key)
containsKey in interface MapcontainsKey in class AbstractHashedMapkey - the key to search forpublic boolean containsValue(Object value)
containsValue in interface MapcontainsValue in class AbstractHashedMapvalue - the value to search forpublic Object get(Object key)
get in interface Mapget in class AbstractHashedMapkey - the keypublic Object put(Object key, Object value)
put in interface Mapput in class AbstractHashedMapkey - the key to add, must not be nullvalue - the value to add, must not be nullNullPointerException - if either the key or value is nullpublic Object remove(Object key)
remove in interface Mapremove in class AbstractHashedMapkey - the mapping to removepublic void clear()
clear in interface Mapclear in class AbstractHashedMappublic MapIterator mapIterator()
mapIterator in interface IterableMapmapIterator in class AbstractHashedMappublic Set entrySet()
next() is called again.
The setValue() method on the toArray entries has no effect.entrySet in interface MapentrySet in class AbstractHashedMappublic Set keySet()
keySet in interface MapkeySet in class AbstractHashedMappublic Collection values()
values in interface Mapvalues in class AbstractHashedMapprotected void purgeBeforeRead()
This implementation calls purge() to maintain a consistent state.
protected void purgeBeforeWrite()
This implementation calls purge() to maintain a consistent state.
protected void purge()
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.
protected void purge(Reference ref)
ref - the reference to purgeprotected AbstractHashedMap.HashEntry getEntry(Object key)
getEntry in class AbstractHashedMapkey - the keyprotected int hashEntry(Object key, Object value)
key - the key to get a hash code for, may be nullvalue - the value to get a hash code for, may be nullprotected boolean isEqualKey(Object key1, Object key2)
This implementation converts the key from the entry to a real reference before comparison.
isEqualKey in class AbstractHashedMapkey1 - the first key to compare passed in from outsidekey2 - the second key extracted from the entry via entry.keyprotected AbstractHashedMap.HashEntry createEntry(AbstractHashedMap.HashEntry next, int hashCode, Object key, Object value)
createEntry in class AbstractHashedMapnext - the next entry in sequencehashCode - the hash code to usekey - the key to storevalue - the value to storeprotected Iterator createEntrySetIterator()
createEntrySetIterator in class AbstractHashedMapprotected Iterator createKeySetIterator()
createKeySetIterator in class AbstractHashedMapprotected Iterator createValuesIterator()
createValuesIterator in class AbstractHashedMapprotected void doWriteObject(ObjectOutputStream out) throws IOException
Serialization is not one of the JDK's nicest topics. Normal serialization will
initialise the superclass before the subclass. Sometimes however, this isn't
what you want, as in this case the put() method on read can be
affected by subclass state.
The solution adopted here is to serialize the state data of this class in
this protected method. This method must be called by the
writeObject() of the first serializable subclass.
Subclasses may override if they have a specific field that must be present on read before this implementation will work. Generally, the read determines what must be serialized here, if anything.
doWriteObject in class AbstractHashedMapout - the output streamIOExceptionprotected void doReadObject(ObjectInputStream in) throws IOException, ClassNotFoundException
Serialization is not one of the JDK's nicest topics. Normal serialization will
initialise the superclass before the subclass. Sometimes however, this isn't
what you want, as in this case the put() method on read can be
affected by subclass state.
The solution adopted here is to deserialize the state data of this class in
this protected method. This method must be called by the
readObject() of the first serializable subclass.
Subclasses may override if the subclass has a specific field that must be present
before put() or calculateThreshold() will work correctly.
doReadObject in class AbstractHashedMapin - the input streamIOExceptionClassNotFoundExceptionCopyright © 2001–2015 The Apache Software Foundation. All rights reserved.