HashedMap (NAF Package 2.5.0 API)

java.lang.Object
- com.grey.base.collections.HashedMap<K,V>

All Implemented Interfaces:

Map<K,V>
```
public final class HashedMap<K,V>
extends Object
implements Map<K,V>
```
This class implements the Map interface, and serves as a zero-garbage replacement for the JRE's HashMap class.
This class may be preferable to the JRE-provided HashMap for high-frequency caches with short-lived entries, as the JRE class not only allocates new memory (in the shape of the Entry class, a linked list of which is rooted in each table slot) when inserting each new key, but also releases that memory when the key is removed. The standard HashMap would therefore generate too much garbage in such a scenario, whereas this class never frees its own memory (though it does of course free its references to deleted key/value pairs) and keeps empty bucket positions available for re-use.
This implementation also has a smaller memory footprint than the JRE HashMap - and smaller than HashedMapEntries as well.
Beware that this class reuses the returned Map.Entry objects when iterating on the entrySet() view.
This is perfectly legal, and well-written applications should be aware of this and not hold references to Map.Entry objects beyond each iteration loop, but some applications may nevertheless fall foul.
If this does cause a problem for badly implemented applications, then they should use HashedMapEntries instead of this class, or alternatively, set the JVM system property -Dgrey.hashedmap.noreuse=Y.
The latter will however negate the primary advantage of this class, namely its non-generation of any garbage, as that will cause it to allocate a new Map.Entry object on each iteration of an entrySet() collection.
FindBugs warns Map implementors not to reuse Map.Entry objects (PZ_DONT_REUSE_ENTRY_OBJECTS_IN_ITERATORS) but concedes it is permitted, and its recommendation is merely good practice to accomodate poorly coded applications. However, this class takes the view that it is not willing to compromise its memory efficiency, and believes it is sufficient to alert its users to possible pitfalls.
This class does return independent Map.Entry nodes in the entrySet() view's toArray() methods, as required by the Java Map spec.
Like the JRE's HashMap, this class implements all optional Map operations.
Beware that this class is single-threaded and non-reentrant.

See Also:

HashedMapEntries

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Constructor Summary

Constructors
Constructor and Description

HashedMap()

HashedMap(int initcap)

HashedMap(int initcap, float factor)

Constructors
Constructor and Description
`HashedMap()`
`HashedMap(int initcap)`
`HashedMap(int initcap, float factor)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object val)`
`Iterator<Map.Entry<K,V>>`	`entriesIterator()` This returns a recycled Map.Entry iterator. Whereas entrySet().iterator() creates a new Iterator object, this method returns a single instance of that iterator type, that is associated with this Map object. This is not a standard Map method, and is obviously unsuitable for multi-threaded use.
`Set<Map.Entry<K,V>>`	`entrySet()`
`V`	`get(Object key)`
`boolean`	`isEmpty()`
`Set<K>`	`keySet()`
`Iterator<K>`	`keysIterator()` This returns a recycled keys iterator. Whereas keySet().iterator() creates a new Iterator object, this method returns a single instance of that iterator type, that is associated with this Map object. This is not a standard Map method, and is obviously unsuitable for multi-threaded use.
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> srcmap)`
`V`	`remove(Object key)`
`int`	`size()`
`String`	`toString()`
`int`	`trimToSize()`
`Collection<V>`	`values()`
`Iterator<V>`	`valuesIterator()` This returns a recycled values iterator. Whereas values().iterator() creates a new Iterator object, this method returns a single instance of that iterator type, that is associated with this Map object. This is not a standard Map method, and is obviously unsuitable for multi-threaded use.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll

- Constructor Detail
  - HashedMap
```
public HashedMap()
```
  - HashedMap
```
public HashedMap(int initcap)
```
  - HashedMap
```
public HashedMap(int initcap,
                 float factor)
```
- Method Detail
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
  - containsValue
```
public boolean containsValue(Object val)
```
    Specified by:
    
    containsValue in interface Map<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> srcmap)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - trimToSize
```
public int trimToSize()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
  - keysIterator
```
public Iterator<K> keysIterator()
```
    This returns a recycled keys iterator.
    Whereas keySet().iterator() creates a new Iterator object, this method returns a single instance of that iterator type, that is associated with this Map object.
    This is not a standard Map method, and is obviously unsuitable for multi-threaded use.
    
    Returns:
    
    The reusable keys iterator. It is created on the first call to this method.
  - valuesIterator
```
public Iterator<V> valuesIterator()
```
    This returns a recycled values iterator.
    Whereas values().iterator() creates a new Iterator object, this method returns a single instance of that iterator type, that is associated with this Map object.
    This is not a standard Map method, and is obviously unsuitable for multi-threaded use.
    
    Returns:
    
    The reusable values iterator. It is created on the first call to this method.
  - entriesIterator
```
public Iterator<Map.Entry<K,V>> entriesIterator()
```
    This returns a recycled Map.Entry iterator.
    Whereas entrySet().iterator() creates a new Iterator object, this method returns a single instance of that iterator type, that is associated with this Map object.
    This is not a standard Map method, and is obviously unsuitable for multi-threaded use.
    
    Returns:
    
    The reusable entries iterator. It is created on the first call to this method.

Class HashedMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

HashedMap

HashedMap

HashedMap

Method Detail

isEmpty

size

clear

containsKey

get

put

remove

containsValue

putAll

trimToSize

toString

keySet

values

entrySet

keysIterator

valuesIterator

entriesIterator