public class FastMap extends Object implements Map, Cloneable, Serializable
This class represents a Map collection with real-time
behavior. Unless the map's size exceeds its current capacity,
no dynamic memory allocation is ever performed and response time is
extremely fast and consistent.
Our benchmark
indicates that FastMap.put(key, value) is up to
5x faster than java.util.HashMap.put(key, value).
This difference is mostly due to the cost of the Map.Entry
allocations that FastMap avoids by recycling its entries
(see note below).
FastMap has a predictable iteration order, which is the order
in which keys were inserted into the map (similar to
java.util.LinkedHashMap collection class).
Applications may change the resizing policy of FastMap
by overriding the sizeChanged() method. For example, to improve
predictability, automatic resizing can be disabled.
This implementation is not synchronized. Multiple threads accessing or modifying the collection must be synchronized externally.
Note: To avoid dynamic memory allocations, FastMap
maintains an internal pool of Map.Entry objects. The size
of the pool is determined by the map's capacity. When an entry is
removed from the map, it is automatically restored to the pool.
This class is public domain (not copyrighted).
| Constructor and Description |
|---|
FastMap()
Creates a
FastMap with a capacity of 256 entries. |
FastMap(int capacity)
Creates a
FastMap with the specified capacity. |
FastMap(Map map)
Creates a
FastMap, copy of the specified Map. |
| Modifier and Type | Method and Description |
|---|---|
int |
capacity()
Returns the capacity of this
FastMap. |
void |
clear()
Removes all mappings from this
FastMap. |
Object |
clone()
Returns a shallow copy of this
FastMap. |
boolean |
containsKey(Object key)
Indicates if this
FastMap contains a mapping for the specified
key. |
boolean |
containsValue(Object value)
Indicates if this
FastMap maps one or more keys to the
specified value. |
Set |
entrySet()
Returns a collection view of the mappings contained in this
FastMap. |
boolean |
equals(Object obj)
Compares the specified object with this
FastMap for equality. |
Object |
get(Object key)
Returns the value to which this
FastMap maps the specified key. |
Map.Entry |
getEntry(Object key)
Returns the entry with the specified key.
|
int |
hashCode()
Returns the hash code value for this
FastMap. |
boolean |
isEmpty()
Indicates if this
FastMap contains no key-value mappings. |
Set |
keySet()
Returns a set view of the keys contained in this
FastMap. |
Object |
put(Object key,
Object value)
Associates the specified value with the specified key in this
FastMap. |
void |
putAll(Map map)
Copies all of the mappings from the specified map to this
FastMap. |
Object |
remove(Object key)
Removes the mapping for this key from this
FastMap if present. |
void |
setCapacity(int newCapacity)
Changes the current capacity of this
FastMap. |
int |
size()
Returns the number of key-value mappings in this
FastMap. |
protected void |
sizeChanged()
This methods is being called when the size of this
FastMap
has changed. |
String |
toString()
Returns a
String representation of this FastMap. |
Collection |
values()
Returns a collection view of the values contained in this
FastMap. |
public FastMap()
FastMap with a capacity of 256 entries.public FastMap(Map map)
FastMap, copy of the specified Map.
If the specified map is not an instance of FastMap, the
newly created map has a capacity set to the specified map's size.
The copy has the same order as the original, regardless of the original
map's implementation:
TreeMap dictionary = ...;
FastMap dictionaryLookup = new FastMap(dictionary);
map - the map whose mappings are to be placed in this map.public FastMap(int capacity)
FastMap with the specified capacity. Unless the
capacity is exceeded, operations on this map do not allocate entries.
For optimum performance, the capacity should be of the same order
of magnitude or larger than the expected map's size.capacity - the number of buckets in the hash table; it also
defines the number of pre-allocated entries.public int size()
FastMap.public int capacity()
FastMap. The capacity defines
the number of buckets in the hash table, as well as the maximum number
of entries the map may contain without allocating memory.public boolean isEmpty()
FastMap contains no key-value mappings.public boolean containsKey(Object key)
FastMap contains a mapping for the specified
key.containsKey in interface Mapkey - the key whose presence in this map is to be tested.true if this map contains a mapping for the
specified key; false otherwise.NullPointerException - if the key is null.public boolean containsValue(Object value)
FastMap maps one or more keys to the
specified value.containsValue in interface Mapvalue - the value whose presence in this map is to be tested.true if this map maps one or more keys to the
specified value.NullPointerException - if the key is null.public Object get(Object key)
FastMap maps the specified key.get in interface Mapkey - the key whose associated value is to be returned.null if there is no mapping for the key.NullPointerException - if key is null.public Map.Entry getEntry(Object key)
key - the key whose associated entry is to be returned.null if none.public Object put(Object key, Object value)
FastMap. If the FastMap previously contained a mapping
for this key, the old value is replaced.put in interface Mapkey - the key with which the specified value is to be associated.value - the value to be associated with the specified key.null if there was no mapping for key.
A null return can also indicate that the map
previously associated null with the specified key.NullPointerException - if the key is null.public void putAll(Map map)
FastMap.putAll in interface Mapmap - the mappings to be stored in this map.NullPointerException - the specified map is null, or
the specified map contains null keys.public Object remove(Object key)
FastMap if present.remove in interface Mapkey - the key whose mapping is to be removed from the map.null if there was no mapping for key.
A null return can also indicate that the map
previously associated null with the specified key.NullPointerException - if the key is null.public void clear()
FastMap.public void setCapacity(int newCapacity)
FastMap. If the capacity
is increased, new entries are allocated and added to the pool.
If the capacity is decreased, entries from the pool are deallocated
(and are eventually garbage collected). The capacity also determined
the number of buckets for the hash table.newCapacity - the new capacity of this map.public Object clone()
FastMap. The keys and
the values themselves are not cloned.public boolean equals(Object obj)
FastMap for equality.
Returns true if the given object is also a map and the two
maps represent the same mappings (regardless of collection iteration
order).public int hashCode()
FastMap.public Collection values()
FastMap. The collection is backed by the map, so changes to
the map are reflected in the collection, and vice-versa.
The collection supports element removal, which removes the corresponding
mapping from this map, via the
Iterator.remove, Collection.remove,
removeAll, retainAll,
and clear operations. It does not support the
add or addAll operations.public Set entrySet()
FastMap. Each element in the returned collection is a
Map.Entry. The collection is backed by the map,
so changes to the map are reflected in the collection, and vice-versa.
The collection supports element removal, which removes the corresponding
mapping from this map, via the
Iterator.remove, Collection.remove,
removeAll, retainAll,
and clear operations. It does not support the
add or addAll operations.public Set keySet()
FastMap.
The set is backed by the map, so changes to the map are reflected
in the set, and vice-versa. The set supports element removal,
which removes the corresponding mapping from this map, via the
Iterator.remove, Collection.remove,
removeAll, retainAll,
and clear operations. It does not support the
add or addAll operations.protected void sizeChanged()
FastMap
has changed. The default behavior is to double the map's capacity
when the map's size reaches the current map's capacity.
Sub-class may override this method to implement custom resizing
policies or to disable automatic resizing. For example:
Map fixedCapacityMap = new FastMap(256) {
protected sizeChanged() {
// Do nothing, automatic resizing disabled.
}
};setCapacity(int)Copyright © 2001-2014 Codehaus. All Rights Reserved.