public class FastMap<K,V> extends Object implements Map<K,V>, 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  FastMapwith a capacity of256entries. | 
| FastMap(int capacity)Creates a  FastMapwith the specified capacity. | 
| FastMap(Map map)Creates a  FastMap, copy of the specifiedMap. | 
| 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  FastMapcontains a mapping for the specified key. | 
| boolean | containsValue(Object value)Indicates if this  FastMapmaps 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  FastMapfor equality. | 
| V | get(Object key)Returns the value to which this  FastMapmaps 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  FastMapcontains 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<? extends K,? extends V> map)Copies all of the mappings from the specified map to this  FastMap. | 
| V | remove(Object key)Removes the mapping for this key from this  FastMapif 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  FastMaphas changed. | 
| String | toString()Returns a  Stringrepresentation of thisFastMap. | 
| 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 Map<K,V>key - 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 Map<K,V>value - 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 V get(Object key)
FastMap maps the specified key.get in interface Map<K,V>key - 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 Map<K,V>key - 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<? extends K,? extends V> map)
FastMap.putAll in interface Map<K,V>map - the mappings to be stored in this map.NullPointerException - the specified map is null, or the specified map contains
             null keys.public V remove(Object key)
FastMap if present.remove in interface Map<K,V>key - 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–2017 Codehaus Plexus. All rights reserved.