gnu.trove

## Class TLongDoubleHashMap

- java.lang.Object
- - gnu.trove.THash
  - - gnu.trove.TPrimitiveHash
    - - gnu.trove.TLongHash
      - - gnu.trove.TLongDoubleHashMap

All Implemented Interfaces:
  TLongHashingStrategy, java.io.Externalizable, java.io.Serializable, java.lang.Cloneable

    public class TLongDoubleHashMap
    extends TLongHash
    implements java.io.Externalizable

An open addressed Map implementation for long keys and double values. Created: Sun Nov 4 08:52:45 2001

Author:
  Eric D. Friedman
See Also:
  Serialized Form

### Field Summary

Fields
`protected double[]` `_values` the values of the map

### Fields inherited from class gnu.trove.TLongHash

`_hashingStrategy, _set`

### Fields inherited from class gnu.trove.TPrimitiveHash

`_states, FREE, FULL, REMOVED`

### Fields inherited from class gnu.trove.THash

`_autoCompactionFactor, _autoCompactRemovesRemaining, _free, _loadFactor, _maxSize, _size, DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR`

### Constructor Summary

Constructors
Constructor and Description
`TLongDoubleHashMap()` Creates a new `TLongDoubleHashMap` instance with the default capacity and load factor.
`TLongDoubleHashMap(int initialCapacity)` Creates a new `TLongDoubleHashMap` instance with a prime capacity equal to or greater than `initialCapacity` and with the default load factor.
`TLongDoubleHashMap(int initialCapacity, float loadFactor)` Creates a new `TLongDoubleHashMap` instance with a prime capacity equal to or greater than `initialCapacity` and with the specified load factor.
`TLongDoubleHashMap(int initialCapacity, float loadFactor, TLongHashingStrategy strategy)` Creates a new `TLongDoubleHashMap` instance with a prime value at or near the specified capacity and load factor.
`TLongDoubleHashMap(int initialCapacity, TLongHashingStrategy strategy)` Creates a new `TLongDoubleHashMap` instance whose capacity is the next highest prime above `initialCapacity + 1` unless that value is already prime.
`TLongDoubleHashMap(TLongHashingStrategy strategy)` Creates a new `TLongDoubleHashMap` instance with the default capacity and load factor.

### Method Summary

Methods
`double` `adjustOrPutValue(long key, double adjust_amount, double put_amount)` Adjusts the primitive value mapped to the key if the key is present in the map.
`boolean` `adjustValue(long key, double amount)` Adjusts the primitive value mapped to key.
`void` `clear()` Empties the map.
`java.lang.Object` `clone()`
`boolean` `containsKey(long key)` checks for the present of `key` in the keys of the map.
`boolean` `containsValue(double val)` checks for the presence of `val` in the values of the map.
`boolean` `equals(java.lang.Object other)` Compares this map with another map for equality of their stored entries.
`boolean` `forEachEntry(TLongDoubleProcedure procedure)` Executes `procedure` for each key/value entry in the map.
`boolean` `forEachKey(TLongProcedure procedure)` Executes `procedure` for each key in the map.
`boolean` `forEachValue(TDoubleProcedure procedure)` Executes `procedure` for each value in the map.
`double` `get(long key)` retrieves the value for `key`
`double[]` `getValues()` Returns the values of the map.
`int` `hashCode()`
`boolean` `increment(long key)` Increments the primitive value mapped to key by 1
`TLongDoubleIterator` `iterator()`
`long[]` `keys()` returns the keys of the map.
`long[]` `keys(long[] a)` returns the keys of the map.
`double` `put(long key, double value)` Inserts a key/value pair into the map.
`void` `putAll(TLongDoubleHashMap map)` Put all the entries from the given map into this map.
`double` `putIfAbsent(long key, double value)` Inserts a key/value pair into the map if the specified key is not already associated with a value.
`void` `readExternal(java.io.ObjectInput in)`
`protected void` `rehash(int newCapacity)` rehashes the map to the new capacity.
`double` `remove(long key)` Deletes a key/value pair from the map.
`protected void` `removeAt(int index)` removes the mapping at `index` from the map.
`boolean` `retainEntries(TLongDoubleProcedure procedure)` Retains only those entries in the map for which the procedure returns a true value.
`protected int` `setUp(int initialCapacity)` initializes the hashtable to a prime capacity which is at least `initialCapacity + 1`.
`java.lang.String` `toString()`
`void` `transformValues(TDoubleFunction function)` Transform the values in this map using `function`.
`void` `writeExternal(java.io.ObjectOutput out)`

### Methods inherited from class gnu.trove.TLongHash

`computeHashCode, contains, forEach, index, insertionIndex`

### Methods inherited from class gnu.trove.TPrimitiveHash

`capacity`

### Methods inherited from class gnu.trove.THash

`calculateGrownCapacity, compact, ensureCapacity, getAutoCompactionFactor, isEmpty, postInsertHook, reenableAutoCompaction, setAutoCompactionFactor, size, tempDisableAutoCompaction, trimToSize`

### Methods inherited from class java.lang.Object

`finalize, getClass, notify, notifyAll, wait, wait, wait`

### Field Detail

#### _values

    protected transient double[] _values

the values of the map

### Constructor Detail

#### TLongDoubleHashMap

    public TLongDoubleHashMap()

Creates a new `TLongDoubleHashMap` instance with the default capacity and load factor.

#### TLongDoubleHashMap

    public TLongDoubleHashMap(int initialCapacity)

Creates a new `TLongDoubleHashMap` instance with a prime capacity equal to or greater than `initialCapacity` and with the default load factor.

Parameters:
  `initialCapacity` - an `int` value

#### TLongDoubleHashMap

    public TLongDoubleHashMap(int initialCapacity,
                      float loadFactor)

Creates a new `TLongDoubleHashMap` instance with a prime capacity equal to or greater than `initialCapacity` and with the specified load factor.

Parameters:
  `initialCapacity` - an `int` value
  `loadFactor` - a `float` value

#### TLongDoubleHashMap

    public TLongDoubleHashMap(TLongHashingStrategy strategy)

Creates a new `TLongDoubleHashMap` instance with the default capacity and load factor.

Parameters:
  `strategy` - used to compute hash codes and to compare keys.

#### TLongDoubleHashMap

    public TLongDoubleHashMap(int initialCapacity,
                      TLongHashingStrategy strategy)

Creates a new `TLongDoubleHashMap` instance whose capacity is the next highest prime above `initialCapacity + 1` unless that value is already prime.

Parameters:
  `initialCapacity` - an `int` value
  `strategy` - used to compute hash codes and to compare keys.

#### TLongDoubleHashMap

    public TLongDoubleHashMap(int initialCapacity,
                      float loadFactor,
                      TLongHashingStrategy strategy)

Creates a new `TLongDoubleHashMap` instance with a prime value at or near the specified capacity and load factor.

Parameters:
  `initialCapacity` - used to find a prime capacity for the table.
  `loadFactor` - used to calculate the threshold over which rehashing takes place.
  `strategy` - used to compute hash codes and to compare keys.

### Method Detail

#### clone

    public java.lang.Object clone()

Overrides:
  `clone` in class `TLongHash`
Returns:
  a deep clone of this collection

#### iterator

    public TLongDoubleIterator iterator()

Returns:
  a TLongDoubleIterator with access to this map's keys and values

#### setUp

    protected int setUp(int initialCapacity)

initializes the hashtable to a prime capacity which is at least `initialCapacity + 1`.

Overrides:
  `setUp` in class `TLongHash`
Parameters:
  `initialCapacity` - an `int` value
Returns:
  the actual capacity chosen

#### put

    public double put(long key,
             double value)

Inserts a key/value pair into the map.

Parameters:
  `key` - an `long` value
  `value` - an `double` value
Returns:
  the previous value associated with `key`, or (long)0 if none was found.

#### putIfAbsent

    public double putIfAbsent(long key,
                     double value)

Inserts a key/value pair into the map if the specified key is not already associated with a value.

Parameters:
  `key` - an `long` value
  `value` - an `double` value
Returns:
  the previous value associated with `key`, or (long)0 if none was found.

#### putAll

    public void putAll(TLongDoubleHashMap map)

Put all the entries from the given map into this map.

Parameters:
  `map` - The map from which entries will be obtained to put into this map.

#### rehash

    protected void rehash(int newCapacity)

rehashes the map to the new capacity.

Specified by:
  `rehash` in class `THash`
Parameters:
  `newCapacity` - an `int` value

#### get

    public double get(long key)

retrieves the value for `key`

Parameters:
  `key` - an `long` value
Returns:
  the value of `key` or (long)0 if no such mapping exists.

#### clear

    public void clear()

Empties the map.

Overrides:
  `clear` in class `THash`

#### remove

    public double remove(long key)

Deletes a key/value pair from the map.

Parameters:
  `key` - an `long` value
Returns:
  an `double` value, or (long)0 if no mapping for key exists

#### equals

    public boolean equals(java.lang.Object other)

Compares this map with another map for equality of their stored entries.

Overrides:
  `equals` in class `java.lang.Object`
Parameters:
  `other` - an `Object` value
Returns:
  a `boolean` value

#### hashCode

    public int hashCode()

Overrides:
  `hashCode` in class `java.lang.Object`

#### removeAt

    protected void removeAt(int index)

removes the mapping at `index` from the map.

Overrides:
  `removeAt` in class `TLongHash`
Parameters:
  `index` - an `int` value

#### getValues

    public double[] getValues()

Returns the values of the map.

Returns:
  a `Collection` value

#### keys

    public long[] keys()

returns the keys of the map.

Returns:
  a `Set` value

#### keys

    public long[] keys(long[] a)

returns the keys of the map.

Parameters:
  `a` - the array into which the elements of the list are to be stored, if it is big enough; otherwise, a new array of the same type is allocated for this purpose.
Returns:
  a `Set` value

#### containsValue

    public boolean containsValue(double val)

checks for the presence of `val` in the values of the map.

Parameters:
  `val` - an `double` value
Returns:
  a `boolean` value

#### containsKey

    public boolean containsKey(long key)

checks for the present of `key` in the keys of the map.

Parameters:
  `key` - an `long` value
Returns:
  a `boolean` value

#### forEachKey

    public boolean forEachKey(TLongProcedure procedure)

Executes `procedure` for each key in the map.

Parameters:
  `procedure` - a `TLongProcedure` value
Returns:
  false if the loop over the keys terminated because the procedure returned false for some key.

#### forEachValue

    public boolean forEachValue(TDoubleProcedure procedure)

Executes `procedure` for each value in the map.

Parameters:
  `procedure` - a `TDoubleProcedure` value
Returns:
  false if the loop over the values terminated because the procedure returned false for some value.

#### forEachEntry

    public boolean forEachEntry(TLongDoubleProcedure procedure)

Executes `procedure` for each key/value entry in the map.

Parameters:
  `procedure` - a `TOLongDoubleProcedure` value
Returns:
  false if the loop over the entries terminated because the procedure returned false for some entry.

#### retainEntries

    public boolean retainEntries(TLongDoubleProcedure procedure)

Retains only those entries in the map for which the procedure returns a true value.

Parameters:
  `procedure` - determines which entries to keep
Returns:
  true if the map was modified.

#### transformValues

    public void transformValues(TDoubleFunction function)

Transform the values in this map using `function`.

Parameters:
  `function` - a `TDoubleFunction` value

#### increment

    public boolean increment(long key)

Increments the primitive value mapped to key by 1

Parameters:
  `key` - the key of the value to increment
Returns:
  true if a mapping was found and modified.

#### adjustValue

    public boolean adjustValue(long key,
                      double amount)

Adjusts the primitive value mapped to key.

Parameters:
  `key` - the key of the value to increment
  `amount` - the amount to adjust the value by.
Returns:
  true if a mapping was found and modified.

#### adjustOrPutValue

    public double adjustOrPutValue(long key,
                          double adjust_amount,
                          double put_amount)

Adjusts the primitive value mapped to the key if the key is present in the map. Otherwise, the `initial_value` is put in the map.

Parameters:
  `key` - the key of the value to increment
  `adjust_amount` - the amount to adjust the value by
  `put_amount` - the value put into the map if the key is not initial present
Returns:
  the value present in the map after the adjustment or put operation
Since:
  2.0b1

#### writeExternal

    public void writeExternal(java.io.ObjectOutput out)
                       throws java.io.IOException

Specified by:
  `writeExternal` in interface `java.io.Externalizable`
Overrides:
  `writeExternal` in class `THash`
Throws:
  `java.io.IOException`

#### readExternal

    public void readExternal(java.io.ObjectInput in)
                      throws java.io.IOException,
                             java.lang.ClassNotFoundException

Specified by:
  `readExternal` in interface `java.io.Externalizable`
Overrides:
  `readExternal` in class `THash`
Throws:
  `java.io.IOException`
  `java.lang.ClassNotFoundException`

#### toString

    public java.lang.String toString()

Overrides:
  `toString` in class `java.lang.Object`