Package gnu.trove.map

# Interface TDoubleIntMap

All Known Implementing Classes:
  `TDoubleIntHashMap`

public interface TDoubleIntMap
Interface for a primitive map of double keys and int values.

## Method Summary

Modifier and Type
Method
Description
`int`
`adjustOrPutValue(double key, int adjust_amount, int put_amount)`
Adjusts the primitive value mapped to the key if the key is present in the map.
`boolean`
`adjustValue(double key, int amount)`
Adjusts the primitive value mapped to key.
`void`
`clear()`
Empties the map.
`boolean`
`containsKey(double key)`
Checks for the present of `key` in the keys of the map.
`boolean`
`containsValue(int val)`
Checks for the presence of `val` in the values of the map.
`boolean`
`forEachEntry(TDoubleIntProcedure 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(TIntProcedure procedure)`
Executes `procedure` for each value in the map.
`int`
`get(double key)`
Retrieves the value for `key`
`double`
`getNoEntryKey()`
Returns the value that will be returned from `get(double)` or `put(double, int)` if no entry exists for a given key.
`int`
`getNoEntryValue()`
Returns the value that will be returned from `get(double)` or `put(double, int)` if no entry exists for a given key.
`boolean`
`increment(double key)`
Increments the primitive value mapped to key by 1
`boolean`
`isEmpty()`
Returns `true` if this map contains no key-value mappings.
`TDoubleIntIterator`
`iterator()`
`double[]`
`keys()`
Returns the keys of the map as an array of `double` values.
`double[]`
`keys(double[] array)`
Returns the keys of the map.
`TDoubleSet`
`keySet()`
Returns the keys of the map as a `TDoubleSet`
`int`
`put(double key, int value)`
Inserts a key/value pair into the map.
`void`
`putAll(TDoubleIntMap map)`
Put all the entries from the given map into this map.
`void`
`putAll(Map<? extends Double,? extends Integer> map)`
Put all the entries from the given Map into this map.
`int`
`putIfAbsent(double key, int value)`
Inserts a key/value pair into the map if the specified key is not already associated with a value.
`int`
`remove(double key)`
Deletes a key/value pair from the map.
`boolean`
`retainEntries(TDoubleIntProcedure procedure)`
Retains only those entries in the map for which the procedure returns a true value.
`int`
`size()`
Returns an `int` value that is the number of elements in the map.
`void`
`transformValues(TIntFunction function)`
Transform the values in this map using `function`.
`TIntCollection`
`valueCollection()`
Returns the values of the map as a `TIntCollection`
`int[]`
`values()`
Returns the values of the map as an array of `#e#` values.
`int[]`
`values(int[] array)`
Returns the values of the map using an existing array.

## Method Details

### getNoEntryKey

double getNoEntryKey()
Returns the value that will be returned from `get(double)` or `put(double, int)` if no entry exists for a given key. The default value is generally zero, but can be changed during construction of the collection.

Returns:
  the value that represents a null key in this collection.

### getNoEntryValue

int getNoEntryValue()
Returns the value that will be returned from `get(double)` or `put(double, int)` if no entry exists for a given key. The default value is generally zero, but can be changed during construction of the collection.

Returns:
  the value that represents a null value in this collection.

### put

int put(double key, int value)
Inserts a key/value pair into the map.

Parameters:
  `key` - an `double` value
  `value` - an `int` value
Returns:
  the previous value associated with `key`, or the "no entry" value if none was found (see `getNoEntryValue()`).

### putIfAbsent

int putIfAbsent(double key, int 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 `int` value
Returns:
  the previous value associated with `key`, or the "no entry" value if none was found (see `getNoEntryValue()`).

### putAll

void putAll(Map<? extends Double,? extends Integer> 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.

### putAll

void putAll(TDoubleIntMap 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.

### get

int get(double key)
Retrieves the value for `key`

Parameters:
  `key` - an `double` value
Returns:
  the previous value associated with `key`, or the "no entry" value if none was found (see `getNoEntryValue()`).

### clear

void clear()
Empties the map.

### isEmpty

boolean isEmpty()
Returns `true` if this map contains no key-value mappings.

Returns:
  `true` if this map contains no key-value mappings

### remove

int remove(double key)
Deletes a key/value pair from the map.

Parameters:
  `key` - an `double` value
Returns:
  the previous value associated with `key`, or the "no entry" value if none was found (see `getNoEntryValue()`).

### size

int size()
Returns an `int` value that is the number of elements in the map.

Returns:
  an `int` value that is the number of elements in the map.

### keySet

TDoubleSet keySet()
Returns the keys of the map as a `TDoubleSet`

Returns:
  the keys of the map as a `TDoubleSet`

### keys

double[] keys()
Returns the keys of the map as an array of `double` values.

Returns:
  the keys of the map as an array of `double` values.

### keys

double[] keys(double[] array)
Returns the keys of the map.

Parameters:
  `array` - 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:
  the keys of the map as an array.

### valueCollection

TIntCollection valueCollection()
Returns the values of the map as a `TIntCollection`

Returns:
  the values of the map as a `TIntCollection`

### values

int[] values()
Returns the values of the map as an array of `#e#` values.

Returns:
  the values of the map as an array of `#e#` values.

### values

int[] values(int[] array)
Returns the values of the map using an existing array.

Parameters:
  `array` - 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:
  the values of the map as an array of `#e#` values.

### containsValue

boolean containsValue(int val)
Checks for the presence of `val` in the values of the map.

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

### containsKey

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

### iterator

TDoubleIntIterator iterator()

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

### forEachKey

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

boolean forEachValue(TIntProcedure procedure)
Executes `procedure` for each value in the map.

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

### forEachEntry

boolean forEachEntry(TDoubleIntProcedure procedure)
Executes `procedure` for each key/value entry in the map.

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

### transformValues

void transformValues(TIntFunction function)
Transform the values in this map using `function`.

Parameters:
  `function` - a `TIntFunction` value

### retainEntries

boolean retainEntries(TDoubleIntProcedure 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.

### increment

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

boolean adjustValue(double key, int 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

int adjustOrPutValue(double key, int adjust_amount, int 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