AbstractHashedMap

The default capacity to use

The default load factor to use

The default threshold to use

The maximum capacity allowed

An object for masking null

Map entries

Entry set

Key set

Load factor, normally 0.75

Modification count for iterators

The size of the map

Size at which to rehash

Values

Constructor only used in deserialization, do not use otherwise.

Constructor which performs no validation on the passed in parameters.

Constructs a new, empty map with the specified initial capacity and default load factor.

Constructs a new, empty map with the specified initial capacity and load factor.

Constructor copying elements from another map.

Clears the map, resetting the size to zero and nullifying references to avoid garbage collection issues.

Checks whether the map contains the specified key.

Checks whether the map contains the specified value.

Gets the entrySet view of the map. Changes made to the view affect this map. To simply iterate through the entries, use mapIterator().

Compares this map with another.

Gets the value mapped to the key specified.

Gets the standard Map hashCode.

Checks whether the map is currently empty.

Gets the keySet view of the map. Changes made to the view affect this map. To simply iterate through the keys, use mapIterator().

Gets an iterator over the map. Changes made to the iterator affect this map.

A MapIterator returns the keys in the map. It also provides convenient methods to get the key and value, and set the value. It avoids the need to create an entrySet/keySet/values object. It also avoids creating the Map.Entry object.

Puts a key-value mapping into this map.

Puts all the values from the specified map into this map.

This implementation iterates around the specified map and uses put(Object, Object).

Removes the specified mapping from this map.

Gets the size of the map.

Gets the map as a String.

Gets the values view of the map. Changes made to the view affect this map. To simply iterate through the values, use mapIterator().

Adds an entry into this map.

This implementation adds the entry to the data storage table. Subclasses could override to handle changes to the map.

Adds a new key-value mapping into this map.

This implementation calls createEntry(), addEntry() and checkCapacity(). It also handles changes to modCount and size. Subclasses could override to fully control adds to the map.

Calculates the new capacity of the map. This implementation normalizes the capacity to a power of two.

Calculates the new threshold of the map, where it will be resized. This implementation uses the load factor.

Checks the capacity of the map and enlarges it if necessary.

This implementation uses the threshold to check if the map needs enlarging

Clones the map without cloning the keys or values.

To implement clone(), a subclass must implement the Cloneable interface and make this method public.

Converts input keys to another object for storage in the map. This implementation masks nulls. Subclasses can override this to perform alternate key conversions.

The reverse conversion can be changed, if required, by overriding the getKey() method in the hash entry.

Creates an entry to store the key-value data.

This implementation creates a new HashEntry instance. Subclasses can override this to return a different storage class, or implement caching.

Creates an entry set iterator. Subclasses can override this to return iterators with different properties.

Creates a key set iterator. Subclasses can override this to return iterators with different properties.

Creates a values iterator. Subclasses can override this to return iterators with different properties.

Kills an entry ready for the garbage collector.

This implementation prepares the HashEntry for garbage collection. Subclasses can override this to implement caching (override clear as well).

Reads the map data from the stream. This method must be overridden if a subclass must be setup before put() is used.

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.

Writes the map data to the stream. This method must be overridden if a subclass must be setup before put() is used.

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.

Changes the size of the data structure to the capacity proposed.

Gets the hashCode field from a HashEntry. Used in subclasses that have no visibility of the field.

Gets the key field from a HashEntry. Used in subclasses that have no visibility of the field.

Gets the next field from a HashEntry. Used in subclasses that have no visibility of the field.

Gets the value field from a HashEntry. Used in subclasses that have no visibility of the field.

Gets the entry mapped to the key specified.

This method exists for subclasses that may need to perform a multi-step process accessing the entry. The public methods in this class don't use this method to gain a small performance boost.

Gets the hash code for the key specified. This implementation uses the additional hashing routine from JDK1.4. Subclasses can override this to return alternate hash codes.

Gets the index into the data storage for the hashCode specified. This implementation uses the least significant bits of the hashCode. Subclasses can override this to return alternate bucketing.

Initialise subclasses during construction, cloning or deserialization.

Compares two keys, in internal converted form, to see if they are equal. This implementation uses the equals method and assumes neither key is null. Subclasses can override this to match differently.

Compares two values, in external form, to see if they are equal. This implementation uses the equals method and assumes neither value is null. Subclasses can override this to match differently.

Removes an entry from the chain stored in a particular index.

This implementation removes the entry from the data storage table. The size is not updated. Subclasses could override to handle changes to the map.

Removes a mapping from the map.

This implementation calls removeEntry() and destroyEntry(). It also handles changes to modCount and size. Subclasses could override to fully control removals from the map.

Reuses an existing key-value mapping, storing completely new data.

This implementation sets all the data fields on the entry. Subclasses could populate additional entry fields.

Updates an existing key-value mapping to change the value.

This implementation calls setValue() on the entry. Subclasses could override to handle changes to the map.