GNU Trove

## gnu.trove
Class TDoubleDoubleHashMap

    java.lang.Object
      gnu.trove.THash
          gnu.trove.TPrimitiveHash
              gnu.trove.TDoubleHash
                  gnu.trove.TDoubleDoubleHashMap

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

    public class TDoubleDoubleHashMap

extends TDoubleHash
implements java.io.Externalizable

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

Author:
  Eric D. Friedman
See Also:
  Serialized Form

Field Summary
`protected double[]` `_values` the values of the map

Fields inherited from class gnu.trove.TDoubleHash
`_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
`TDoubleDoubleHashMap()` Creates a new `TDoubleDoubleHashMap` instance with the default capacity and load factor.
`TDoubleDoubleHashMap(int initialCapacity)` Creates a new `TDoubleDoubleHashMap` instance with a prime capacity equal to or greater than `initialCapacity` and with the default load factor.
`TDoubleDoubleHashMap(int initialCapacity, float loadFactor)` Creates a new `TDoubleDoubleHashMap` instance with a prime capacity equal to or greater than `initialCapacity` and with the specified load factor.
`TDoubleDoubleHashMap(int initialCapacity, float loadFactor, TDoubleHashingStrategy strategy)` Creates a new `TDoubleDoubleHashMap` instance with a prime value at or near the specified capacity and load factor.
`TDoubleDoubleHashMap(int initialCapacity, TDoubleHashingStrategy strategy)` Creates a new `TDoubleDoubleHashMap` instance whose capacity is the next highest prime above `initialCapacity + 1` unless that value is already prime.
`TDoubleDoubleHashMap(TDoubleHashingStrategy strategy)` Creates a new `TDoubleDoubleHashMap` instance with the default capacity and load factor.

Method Summary
`double` `adjustOrPutValue(double 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(double key, double amount)` Adjusts the primitive value mapped to key.
`void` `clear()` Empties the map.
`java.lang.Object` `clone()`
`boolean` `containsKey(double 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(TDoubleDoubleProcedure procedure)` Executes `procedure` for each key/value entry in the map.
`boolean` `forEachKey(TDoubleProcedure procedure)` Executes `procedure` for each key in the map.
`boolean` `forEachValue(TDoubleProcedure procedure)` Executes `procedure` for each value in the map.
`double` `get(double key)` retrieves the value for `key`
`double[]` `getValues()` Returns the values of the map.
`int` `hashCode()`
`boolean` `increment(double key)` Increments the primitive value mapped to key by 1
`TDoubleDoubleIterator` `iterator()`
`double[]` `keys()` returns the keys of the map.
`double[]` `keys(double[] a)` returns the keys of the map.
`double` `put(double key, double value)` Inserts a key/value pair into the map.
`void` `putAll(TDoubleDoubleHashMap map)` Put all the entries from the given map into this map.
`double` `putIfAbsent(double 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(double key)` Deletes a key/value pair from the map.
`protected void` `removeAt(int index)` removes the mapping at `index` from the map.
`boolean` `retainEntries(TDoubleDoubleProcedure 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.TDoubleHash
`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

### TDoubleDoubleHashMap

    public TDoubleDoubleHashMap()

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

### TDoubleDoubleHashMap

    public TDoubleDoubleHashMap(int initialCapacity)

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

  Parameters:
    `initialCapacity` - an `int` value

### TDoubleDoubleHashMap

    public TDoubleDoubleHashMap(int initialCapacity,
                                float loadFactor)

  Creates a new `TDoubleDoubleHashMap` 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

### TDoubleDoubleHashMap

    public TDoubleDoubleHashMap(TDoubleHashingStrategy strategy)

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

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

### TDoubleDoubleHashMap

    public TDoubleDoubleHashMap(int initialCapacity,
                                TDoubleHashingStrategy strategy)

  Creates a new `TDoubleDoubleHashMap` 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.

### TDoubleDoubleHashMap

    public TDoubleDoubleHashMap(int initialCapacity,
                                float loadFactor,
                                TDoubleHashingStrategy strategy)

  Creates a new `TDoubleDoubleHashMap` 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 `TDoubleHash`
  Returns:
    a deep clone of this collection

### iterator

    public TDoubleDoubleIterator iterator()

  Returns:
    a TDoubleDoubleIterator 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 `TDoubleHash`
  Parameters:
    `initialCapacity` - an `int` value
  Returns:
    the actual capacity chosen

### put

    public double put(double key,
                      double value)

  Inserts a key/value pair into the map.

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

### putIfAbsent

    public double putIfAbsent(double 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 `double` value
    `value` - an `double` value
  Returns:
    the previous value associated with `key`, or (double)0 if none was found.

### putAll

    public void putAll(TDoubleDoubleHashMap 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(double key)

  retrieves the value for `key`

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

### clear

    public void clear()

  Empties the map.

  Overrides:
    `clear` in class `THash`

### remove

    public double remove(double key)

  Deletes a key/value pair from the map.

  Parameters:
    `key` - an `double` value
  Returns:
    an `double` value, or (double)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 `TDoubleHash`
  Parameters:
    `index` - an `int` value

### getValues

    public double[] getValues()

  Returns the values of the map.

  Returns:
    a `Collection` value

### keys

    public double[] keys()

  returns the keys of the map.

  Returns:
    a `Set` value

### keys

    public double[] keys(double[] 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(double key)

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

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

### forEachKey

    public boolean forEachKey(TDoubleProcedure procedure)

  Executes `procedure` for each key in the map.

  Parameters:
    `procedure` - a `TDoubleProcedure` 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(TDoubleDoubleProcedure procedure)

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

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

### retainEntries

    public boolean retainEntries(TDoubleDoubleProcedure 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(double 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(double 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(double 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`

GNU Trove

GNU Trove is copyright © 2001-2009 Eric D. Friedman. All Rights Reserved.