RapidFastMap (utils4j)

java.lang.Object
- com.varra.util.RapidFastMap<K,V>

Type Parameters:

K - the key type

V - the value type

All Implemented Interfaces:

Serializable, Cloneable
```
public class RapidFastMap<K,V>
extends Object
implements Cloneable, Serializable
```
A RapidFastMap which provides a fast map with concurrency. A thread safe implementation is added on top of the Hash Map mechanism.

Version:

1.0

Author:

Rajakrishna V. Reddy

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`RapidFastMap()` Instantiates a new empty rapid fast map with a default initial capacity, load factor, and concurrencyLevel.
`RapidFastMap(Map<? extends K,? extends V> tempMap)` Instantiates a new rapid fast map with the given map elements and its capacity.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Removes all mappings from this map.
`boolean`	`containsKey(K key)` Tests if the specified object is a key in this table.
`boolean`	`containsValue(V value)` Returns `true` if this map maps one or more keys to the specified value.
`Collection<V>`	`elements()` Returns an enumeration of the values in this table.
`Set<Map.Entry<K,V>>`	`entrySet()` Returns a collection view of the mappings contained in this map.
`boolean`	`equals(Object o)` Compares the specified object with this map for equality.
`V`	`get(K key)` Returns the value to which the specified key is mapped in this table.
`Map<K,V>`	`getAsMap()` Returns this Object as `Map`.
`int`	`hashCode()` Returns the hash code value for this map.
`boolean`	`isEmpty()` Returns `true` if this map contains no key-value mappings.
`Set<K>`	`keys()` Returns an enumeration of the keys in this table.
`Set<K>`	`keySet()` Returns a set view of the keys contained in this map.
`V`	`put(K key, V value)` Maps the specified `key` to the specified `value` in this table.
`void`	`putAll(Map<? extends K,? extends V> t)` Copies all of the mappings from the specified map to this one.
`V`	`putIfAbsent(K key, V value)` If the specified key is not already associated with a value, associate it with the given value.
`V`	`remove(K key)` Removes the key (and its corresponding value) from this table.
`boolean`	`remove(K key, V value)` Remove entry for key only if currently mapped to given value.
`V`	`replace(K key, V value)` Replace entry for key only if currently mapped to some value.
`boolean`	`replace(K key, V oldValue, V newValue)` Replace entry for key only if currently mapped to given value.
`int`	`size()` Returns the number of key-value mappings in this map.
`String`	`toString()` Returns a string representation of this map.
`Collection<V>`	`values()` Returns a collection view of the values contained in this map.

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - RapidFastMap
```
public RapidFastMap()
```
    Instantiates a new empty rapid fast map with a default initial capacity, load factor, and concurrencyLevel.
  - RapidFastMap
```
public RapidFastMap(Map<? extends K,? extends V> tempMap)
```
    Instantiates a new rapid fast map with the given map elements and its capacity.
    
    Parameters:
    
    tempMap - the temp map
- Method Detail
  - isEmpty
```
public boolean isEmpty()
```
    Returns true if this map contains no key-value mappings.
    This implementation returns size() == 0.
    
    Returns:
    
    true if this map contains no key-value mappings.
  - size
```
public int size()
```
    Returns the number of key-value mappings in this map. If the map contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
    This implementation returns entrySet().size().
    
    Returns:
    
    the number of key-value mappings in this map.
  - get
```
public V get(K key)
```
    Returns the value to which the specified key is mapped in this table.
    
    Parameters:
    
    key - a key in the table.
    
    Returns:
    
    the value to which the key is mapped in this table; null if the key is not mapped to any value in this table.
    
    Throws:
    
    NullPointerException - if the key is null.
  - getAsMap
```
public Map<K,V> getAsMap()
```
    Returns this Object as Map.
    
    Returns:
    
    this as map
  - containsKey
```
public boolean containsKey(K key)
```
    Tests if the specified object is a key in this table.
    
    Parameters:
    
    key - possible key.
    
    Returns:
    
    true if and only if the specified object is a key in this table, as determined by the equals method; false otherwise.
    
    Throws:
    
    NullPointerException - if the key is null.
  - containsValue
```
public boolean containsValue(V value)
```
    Returns true if this map maps one or more keys to the specified value. Note: This method requires a full internal traversal of the hash table, and so is much slower than method containsKey.
    
    Parameters:
    
    value - value whose presence in this map is to be tested.
    
    Returns:
    
    true if this map maps one or more keys to the specified value.
    
    Throws:
    
    NullPointerException - if the value is null.
  - put
```
public V put(K key,
             V value)
```
    Maps the specified key to the specified value in this table. Neither the key nor the value can be null.
    The value can be retrieved by calling the get method with a key that is equal to the original key.
    
    Parameters:
    
    key - the table key.
    
    value - the value.
    
    Returns:
    
    the previous value of the specified key in this table, or null if it did not have one.
    
    Throws:
    
    NullPointerException - if the key or value is null.
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value)
```
    If the specified key is not already associated with a value, associate it with the given value. This is equivalent to
```
 if (!map.containsKey(key))
        return map.put(key, value);
 else
        return map.get(key);
 
```
    Except that the action is performed atomically.
    Parameters:
    
    key - key with which the specified value is to be associated.
    
    value - value to be associated with the specified key.
    
    Returns:
    
    previous value associated with specified key, or null if there was no mapping for key.
    
    Throws:
    
    NullPointerException - if the specified key or value is null.
  - putAll
```
public void putAll(Map<? extends K,? extends V> t)
```
    Copies all of the mappings from the specified map to this one. These mappings replace any mappings that this map had for any of the keys currently in the specified Map.
    
    Parameters:
    
    t - Mappings to be stored in this map.
  - remove
```
public V remove(K key)
```
    Removes the key (and its corresponding value) from this table. This method does nothing if the key is not in the table.
    
    Parameters:
    
    key - the key that needs to be removed.
    
    Returns:
    
    the value to which the key had been mapped in this table, or null if the key did not have a mapping.
    
    Throws:
    
    NullPointerException - if the key is null.
  - remove
```
public boolean remove(K key,
                      V value)
```
    Remove entry for key only if currently mapped to given value. Acts as
```
 if (map.get(key).equals(value))
 {
        map.remove(key);
        return true;
 }
 else
        return false;
 
```
    except that the action is performed atomically.
    Parameters:
    
    key - key with which the specified value is associated.
    
    value - value associated with the specified key.
    
    Returns:
    
    true if the value was removed
    
    Throws:
    
    NullPointerException - if the specified key is null.
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Replace entry for key only if currently mapped to given value. Acts as
```
 if (map.get(key).equals(oldValue))
 {
        map.put(key, newValue);
        return true;
 }
 else
        return false;
 
```
    except that the action is performed atomically.
    Parameters:
    
    key - key with which the specified value is associated.
    
    oldValue - value expected to be associated with the specified key.
    
    newValue - value to be associated with the specified key.
    
    Returns:
    
    true if the value was replaced
    
    Throws:
    
    NullPointerException - if the specified key or values are null.
  - replace
```
public V replace(K key,
                 V value)
```
    Replace entry for key only if currently mapped to some value. Acts as
```
  if ((map.containsKey(key)) {
     return map.put(key, value);
 } else return null;
 
```
    except that the action is performed atomically.
    Parameters:
    
    key - key with which the specified value is associated.
    
    value - value to be associated with the specified key.
    
    Returns:
    
    previous value associated with specified key, or null if there was no mapping for key.
    
    Throws:
    
    NullPointerException - if the specified key or value is null.
  - clear
```
public void clear()
```
    Removes all mappings from this map.
  - keySet
```
public Set<K> keySet()
```
    Returns a set view of the keys contained in this map. 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, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations. The view's returned iterator is a "weakly consistent" iterator that will never throw ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
    
    Returns:
    
    a set view of the keys contained in this map.
  - values
```
public Collection<V> values()
```
    Returns a collection view of the values contained in this map. 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. The view's returned iterator is a "weakly consistent" iterator that will never throw ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
    
    Returns:
    
    a collection view of the values contained in this map.
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Returns a collection view of the mappings contained in this map. 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 the map, via the Iterator.remove, Collection.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations. The view's returned iterator is a "weakly consistent" iterator that will never throw ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.
    
    Returns:
    
    a collection view of the mappings contained in this map.
  - keys
```
public Set<K> keys()
```
    Returns an enumeration of the keys in this table.
    
    Returns:
    
    an enumeration of the keys in this table.
    
    See Also:
    
    keySet()
  - elements
```
public Collection<V> elements()
```
    Returns an enumeration of the values in this table.
    
    Returns:
    
    an enumeration of the values in this table.
    
    See Also:
    
    values()
  - equals
```
public boolean equals(Object o)
```
    Compares the specified object with this map for equality. Returns true if the given object is also a map and the two maps represent the same mappings. More formally, two maps t1 and t2 represent the same mappings if t1.keySet().equals(t2.keySet()) and for every key k in t1.keySet(), (t1.get(k)==null ? t2.get(k)==null : t1.get(k).equals(t2.get(k))). This ensures that the equals method works properly across different implementations of the map interface.
    This implementation first checks if the specified object is this map; if so it returns true. Then, it checks if the specified object is a map whose size is identical to the size of this set; if not, it returns false. If so, it iterates over this map's entrySet collection, and checks that the specified map contains each mapping that this map contains. If the specified map fails to contain such a mapping, false is returned. If the iteration completes, true is returned.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o - object to be compared for equality with this map.
    
    Returns:
    
    true if the specified object is equal to this map.
  - hashCode
```
public int hashCode()
```
    Returns the hash code value for this map. The hash code of a map is defined to be the sum of the hash codes of each entry in the map's entrySet() view. This ensures that t1.equals(t2) implies that t1.hashCode()==t2.hashCode() for any two maps t1 and t2, as required by the general contract of Object.hashCode.
    This implementation iterates over entrySet(), calling hashCode on each element (entry) in the Collection, and adding up the results.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    the hash code value for this map.
    
    See Also:
    
    Map.Entry.hashCode(), Object.hashCode(), Object.equals(Object), Set.equals(Object)
  - toString
```
public String toString()
```
    Returns a string representation of this map. The string representation consists of a list of key-value mappings in the order returned by the map's entrySet view's iterator, enclosed in braces ( "{}"). Adjacent mappings are separated by the characters ", " (comma and space). Each key-value mapping is rendered as the key followed by an equals sign ("=") followed by the associated value. Keys and values are converted to strings as by String.valueOf(Object).
    This implementation creates an empty string buffer, appends a left brace, and iterates over the map's entrySet view, appending the string representation of each map.entry in turn. After appending each entry except the last, the string ", " is appended. Finally a right brace is appended. A string is obtained from the stringBuffer, and returned.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a String representation of this map.

Class RapidFastMap<K,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RapidFastMap

RapidFastMap

Method Detail

isEmpty

size

get

getAsMap

containsKey

containsValue

put

putIfAbsent

putAll

remove

remove

replace

replace

clear

keySet

values

entrySet

keys

elements

equals

hashCode

toString