java.lang.Object | |||
↳ | java.util.AbstractMap<K, V> | ||
↳ | org.apache.commons.collections.map.AbstractHashedMap | ||
↳ | org.apache.commons.collections.map.AbstractReferenceMap |
Known Direct Subclasses |
An abstract implementation of a hash-based map that allows the entries to be removed by the garbage collector.
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 synchronizedMap(Map
to
provide synchronized access to a ReferenceMap
.
Nested Classes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
AbstractReferenceMap.ReferenceEntry | A MapEntry implementation for the map. |
Constants | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
int | HARD | Constant indicating that hard references should be used | |||||||||
int | SOFT | Constant indicating that soft references should be used | |||||||||
int | WEAK | Constant indicating that weak references should be used |
[Expand]
Inherited Constants | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
org.apache.commons.collections.map.AbstractHashedMap
|
Fields | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
keyType | The reference type for keys. | ||||||||||
purgeValues | Should the value be automatically purged when the associated key has been collected? | ||||||||||
valueType | The reference type for values. |
[Expand]
Inherited Fields | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
org.apache.commons.collections.map.AbstractHashedMap
|
Protected Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Constructor used during deserialization.
| |||||||||||
Constructs a new empty map with the specified reference types,
load factor and initial capacity.
|
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Clears this map.
| |||||||||||
Checks whether the map contains the specified key.
| |||||||||||
Checks whether the map contains the specified value.
| |||||||||||
Returns a set view of this map's entries.
| |||||||||||
Gets the value mapped to the key specified.
| |||||||||||
Checks whether the map is currently empty.
| |||||||||||
Returns a set view of this map's keys.
| |||||||||||
Gets a MapIterator over the reference map.
| |||||||||||
Puts a key-value mapping into this map.
| |||||||||||
Removes the specified mapping from this map.
| |||||||||||
Gets the size of the map.
| |||||||||||
Returns a collection view of this map's values.
|
Protected Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Creates a ReferenceEntry instead of a HashEntry.
| |||||||||||
Creates an entry set iterator.
| |||||||||||
Creates an key set iterator.
| |||||||||||
Creates an values iterator.
| |||||||||||
Replaces the superclassm method to read the state of this class.
| |||||||||||
Replaces the superclass method to store the state of this class.
| |||||||||||
Gets the entry mapped to the key specified.
| |||||||||||
Gets the hash code for a MapEntry.
| |||||||||||
Initialise this subclass during construction, cloning or deserialization.
| |||||||||||
Compares two keys, in internal converted form, to see if they are equal.
| |||||||||||
Purges stale mappings from this map.
| |||||||||||
Purges the specified reference.
| |||||||||||
Purges stale mappings from this map before read operations.
| |||||||||||
Purges stale mappings from this map before write operations.
|
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
org.apache.commons.collections.map.AbstractHashedMap
| |||||||||||
From class
java.util.AbstractMap
| |||||||||||
From class
java.lang.Object
| |||||||||||
From interface
java.util.Map
| |||||||||||
From interface
org.apache.commons.collections.IterableMap
|
Constant indicating that hard references should be used
Constant indicating that soft references should be used
Constant indicating that weak references should be used
The reference type for keys. Must be HARD, SOFT, WEAK.
Should the value be automatically purged when the associated key has been collected?
The reference type for values. Must be HARD, SOFT, WEAK.
Constructor used during deserialization.
Constructs a new empty map with the specified reference types, load factor and initial capacity.
keyType | the type of reference to use for keys;
must be HARD , SOFT , WEAK |
---|---|
valueType | the type of reference to use for values;
must be HARD , SOFT , WEAK |
capacity | the initial capacity for the map |
loadFactor | the load factor for the map |
purgeValues | should the value be automatically purged when the key is garbage collected |
Clears this map.
Checks whether the map contains the specified key.
key | the key to search for |
---|
Checks whether the map contains the specified value.
value | the value to search for |
---|
Returns a set view of this map's entries.
An iterator returned entry is valid until next()
is called again.
The setValue()
method on the toArray
entries has no effect.
Gets the value mapped to the key specified.
key | the key |
---|
Checks whether the map is currently empty.
Gets a MapIterator over the reference map. The iterator only returns valid key/value pairs.
Puts a key-value mapping into this map. Neither the key nor the value may be null.
key | the key to add, must not be null |
---|---|
value | the value to add, must not be null |
NullPointerException | if either the key or value is null |
---|
Removes the specified mapping from this map.
key | the mapping to remove |
---|
Gets the size of the map.
Returns a collection view of this map's values.
Creates a ReferenceEntry instead of a HashEntry.
next | the next entry in sequence |
---|---|
hashCode | the hash code to use |
key | the key to store |
value | the value to store |
Creates an entry set iterator.
Replaces the superclassm method to read the state of this class.
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.
in | the input stream |
---|
Replaces the superclass method to store the state of this class.
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.
out | the output stream |
---|
IOException |
---|
Gets the entry mapped to the key specified.
key | the key |
---|
Gets the hash code for a MapEntry. Subclasses can override this, for example to use the identityHashCode.
key | the key to get a hash code for, may be null |
---|---|
value | the value to get a hash code for, may be null |
Initialise this subclass during construction, cloning or deserialization.
Compares two keys, in internal converted form, to see if they are equal.
This implementation converts the key from the entry to a real reference before comparison.
key1 | the first key to compare passed in from outside |
---|---|
key2 | the second key extracted from the entry via entry.key |
Purges stale mappings from this map.
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.
Purges the specified reference.
ref | the reference to purge |
---|
Purges stale mappings from this map before read operations.
This implementation calls purge()
to maintain a consistent state.
Purges stale mappings from this map before write operations.
This implementation calls purge()
to maintain a consistent state.