OpenIntObjectHashMap (Orika

java.lang.Object
- ma.glasnost.orika.cern.colt.map.OpenIntObjectHashMap

```
public class OpenIntObjectHashMap
extends Object
```
Hash map holding (key,value) associations of type (int-->Object); Automatically grows and shrinks as needed; Implemented using open addressing with double hashing. First see the package summary and javadoc tree view to get the broad picture. Overrides many methods for performance reasons only.

Version:

1.0, 09/24/99

Author:

wolfgang.hoschek@cern.ch, matt.deboer@gmail.com Modified source to remove unused methods and combined superclass methods into single class.

See Also:

HashMap

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`distinct` The number of distinct associations in the map; its "size()".
`protected int`	`freeEntries` The number of table entries in state==FREE.
`protected double`	`maxLoadFactor` The maximum load factor for the hashtable.
`protected double`	`minLoadFactor` The minimum load factor for the hashtable.
`protected byte[]`	`state` The state of each hash table entry (FREE, FULL, REMOVED).
`protected int[]`	`table` The hash table keys.
`protected Object[]`	`values` The hash table values.

Constructor Summary

Constructors
Constructor and Description
`OpenIntObjectHashMap()` Constructs an empty map with default capacity and default load factors.
`OpenIntObjectHashMap(int initialCapacity)` Constructs an empty map with the specified initial capacity and default load factors.
`OpenIntObjectHashMap(int initialCapacity, double minLoadFactor, double maxLoadFactor)` Constructs an empty map with the specified initial capacity and the specified minimum and maximum load factor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected int`	`chooseGrowCapacity(int size, double minLoad, double maxLoad)` Chooses a new prime table capacity optimized for growing that (approximately) satisfies the invariant `c * minLoadFactor <= size <= c * maxLoadFactor` and has at least one FREE slot for the given size.
`protected int`	`chooseHighWaterMark(int capacity, double maxLoad)` Returns new high water mark threshold based on current capacity and maxLoadFactor.
`protected int`	`chooseShrinkCapacity(int size, double minLoad, double maxLoad)` Chooses a new prime table capacity optimized for shrinking that (approximately) satisfies the invariant `c * minLoadFactor <= size <= c * maxLoadFactor` and has at least one FREE slot for the given size.
`void`	`clear()` Removes all entries from this map
`boolean`	`containsKey(int key)` Returns `true` if the receiver contains the specified key.
`Object`	`get(int key)` Returns the value associated with the specified key.
`protected int`	`indexOfInsertion(int key)`
`protected int`	`indexOfKey(int key)`
`protected int`	`nextPrime(int desiredCapacity)` Returns a prime number which is `>= desiredCapacity` and very close to `desiredCapacity` (within 11% if `desiredCapacity >= 1000`).
`boolean`	`put(int key, Object value)` Associates the given key with the given value.
`protected void`	`rehash(int newCapacity)` Rehashes the contents of the receiver into a new table with a smaller or larger capacity.
`protected void`	`setUp(int initialCapacity, double minLoadFactor, double maxLoadFactor)` Initializes the receiver.

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

- Field Detail
  - table
```
protected int[] table
```
    The hash table keys.
  - values
```
protected Object[] values
```
    The hash table values.
  - state
```
protected byte[] state
```
    The state of each hash table entry (FREE, FULL, REMOVED).
  - freeEntries
```
protected int freeEntries
```
    The number of table entries in state==FREE.
  - distinct
```
protected int distinct
```
    The number of distinct associations in the map; its "size()".
  - minLoadFactor
```
protected double minLoadFactor
```
    The minimum load factor for the hashtable.
  - maxLoadFactor
```
protected double maxLoadFactor
```
    The maximum load factor for the hashtable.
- Constructor Detail
  - OpenIntObjectHashMap
```
public OpenIntObjectHashMap()
```
    Constructs an empty map with default capacity and default load factors.
  - OpenIntObjectHashMap
```
public OpenIntObjectHashMap(int initialCapacity)
```
    Constructs an empty map with the specified initial capacity and default load factors.
    
    Parameters:
    
    initialCapacity - the initial capacity of the map.
    
    Throws:
    
    IllegalArgumentException - if the initial capacity is less than zero.
  - OpenIntObjectHashMap
```
public OpenIntObjectHashMap(int initialCapacity,
                            double minLoadFactor,
                            double maxLoadFactor)
```
    Constructs an empty map with the specified initial capacity and the specified minimum and maximum load factor.
    
    Parameters:
    
    initialCapacity - the initial capacity.
    
    minLoadFactor - the minimum load factor.
    
    maxLoadFactor - the maximum load factor.
    
    Throws:
    
    IllegalArgumentException - if initialCapacity < 0 || (minLoadFactor < 0.0 || minLoadFactor >= 1.0) || (maxLoadFactor <= 0.0 || maxLoadFactor >= 1.0) || (minLoadFactor >= maxLoadFactor) .
- Method Detail
  - containsKey
```
public boolean containsKey(int key)
```
    Returns true if the receiver contains the specified key.
    
    Parameters:
    
    key - the key to test for
    
    Returns:
    
    true if the receiver contains the specified key.
  - get
```
public Object get(int key)
```
    Returns the value associated with the specified key. It is often a good idea to first check with containsKey(int) whether the given key has a value associated or not, i.e. whether there exists an association for the given key or not.
    
    Parameters:
    
    key - the key to be searched for.
    
    Returns:
    
    the value associated with the specified key; null if no such key is present.
  - indexOfInsertion
```
protected int indexOfInsertion(int key)
```
    Parameters:
    
    key - the key to be added to the receiver.
    
    Returns:
    
    the index where the key would need to be inserted, if it is not already contained. Returns -index-1 if the key is already contained at slot index. Therefore, if the returned index < 0, then it is already contained at slot -index-1. If the returned index >= 0, then it is NOT already contained and should be inserted at slot index.
  - indexOfKey
```
protected int indexOfKey(int key)
```
    Parameters:
    
    key - the key to be searched in the receiver.
    
    Returns:
    
    the index where the key is contained in the receiver, returns -1 if the key was not found.
  - clear
```
public void clear()
```
    Removes all entries from this map
  - chooseGrowCapacity
```
protected int chooseGrowCapacity(int size,
                                 double minLoad,
                                 double maxLoad)
```
    Chooses a new prime table capacity optimized for growing that (approximately) satisfies the invariant c * minLoadFactor <= size <= c * maxLoadFactor and has at least one FREE slot for the given size.
  - nextPrime
```
protected int nextPrime(int desiredCapacity)
```
    Returns a prime number which is >= desiredCapacity and very close to desiredCapacity (within 11% if desiredCapacity >= 1000).
    
    Parameters:
    
    desiredCapacity - the capacity desired by the user.
    
    Returns:
    
    the capacity which should be used for a hashtable.
  - chooseHighWaterMark
```
protected int chooseHighWaterMark(int capacity,
                                  double maxLoad)
```
    Returns new high water mark threshold based on current capacity and maxLoadFactor.
    
    Returns:
    
    int the new threshold.
  - put
```
public boolean put(int key,
                   Object value)
```
    Associates the given key with the given value. Replaces any old (key,someOtherValue) association, if existing.
    
    Parameters:
    
    key - the key the value shall be associated with.
    
    value - the value to be associated.
    
    Returns:
    
    true if the receiver did not already contain such a key; false if the receiver did already contain such a key - the new value has now replaced the formerly associated value.
  - rehash
```
protected void rehash(int newCapacity)
```
    Rehashes the contents of the receiver into a new table with a smaller or larger capacity. This method is called automatically when the number of keys in the receiver exceeds the high water mark or falls below the low water mark.
  - chooseShrinkCapacity
```
protected int chooseShrinkCapacity(int size,
                                   double minLoad,
                                   double maxLoad)
```
    Chooses a new prime table capacity optimized for shrinking that (approximately) satisfies the invariant c * minLoadFactor <= size <= c * maxLoadFactor and has at least one FREE slot for the given size.
  - setUp
```
protected void setUp(int initialCapacity,
                     double minLoadFactor,
                     double maxLoadFactor)
```
    Initializes the receiver.
    
    Parameters:
    
    initialCapacity - the initial capacity of the receiver.
    
    minLoadFactor - the minLoadFactor of the receiver.
    
    maxLoadFactor - the maxLoadFactor of the receiver.
    
    Throws:
    
    IllegalArgumentException - if initialCapacity < 0 || (minLoadFactor < 0.0 || minLoadFactor >= 1.0) || (maxLoadFactor <= 0.0 || maxLoadFactor >= 1.0) || (minLoadFactor >= maxLoadFactor) .

Class OpenIntObjectHashMap

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

table

values

state

freeEntries

distinct

minLoadFactor

maxLoadFactor

Constructor Detail

OpenIntObjectHashMap

OpenIntObjectHashMap

OpenIntObjectHashMap

Method Detail

containsKey

get

indexOfInsertion

indexOfKey

clear

chooseGrowCapacity

nextPrime

chooseHighWaterMark

put

rehash

chooseShrinkCapacity

setUp