Package gnu.trove.map

# Interface TObjectCharMap<K>

All Known Implementing Classes:
  `TObjectCharCustomHashMap`, `TObjectCharHashMap`

public interface TObjectCharMap<K>
Interface for a primitive map of Object keys and char values.

## Method Summary

Modifier and Type
Method
Description
`char`
`adjustOrPutValue(K key, char adjust_amount, char put_amount)`
Adjusts the primitive value mapped to the key if the key is present in the map.
`boolean`
`adjustValue(K key, char amount)`
Adjusts the primitive value mapped to key.
`void`
`clear()`
Removes all of the mappings from this map (optional operation).
`boolean`
`containsKey(Object key)`
Returns `true` if this map contains a mapping for the specified key.
`boolean`
`containsValue(char value)`
Returns `true` if this map maps one or more keys to the specified value.
`boolean`
`equals(Object o)`
Compares the specified object with this map for equality.
`boolean`
`forEachEntry(TObjectCharProcedure<? super K> procedure)`
Executes `procedure` for each key/value entry in the map.
`boolean`
`forEachKey(TObjectProcedure<? super K> procedure)`
Executes `procedure` for each key in the map.
`boolean`
`forEachValue(TCharProcedure procedure)`
Executes `procedure` for each value in the map.
`char`
`get(Object key)`
Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.
`char`
`getNoEntryValue()`
Returns the value that will be returned from `get(java.lang.Object)` or `put(K, char)` if no entry exists for a given key.
`int`
`hashCode()`
Returns the hash code value for this map.
`boolean`
`increment(K key)`
Increments the primitive value mapped to key by 1
`boolean`
`isEmpty()`
Returns `true` if this map contains no key-value mappings.
`TObjectCharIterator<K>`
`iterator()`
Returns a `TObjectCharIterator` with access to this map's keys and values.
`Object[]`
`keys()`
Returns a copy of the keys of the map as an array.
`K[]`
`keys(K[] array)`
Returns a copy of the keys of the map as an array.
`Set<K>`
`keySet()`
Returns a `Set` view of the keys contained in this map.
`char`
`put(K key, char value)`
Associates the specified value with the specified key in this map (optional operation).
`void`
`putAll(TObjectCharMap<? extends K> map)`
Put all the entries from the given map into this map.
`void`
`putAll(Map<? extends K,? extends Character> m)`
Copies all of the mappings from the specified map to this map (optional operation).
`char`
`putIfAbsent(K key, char value)`
Inserts a key/value pair into the map if the specified key is not already associated with a value.
`char`
`remove(Object key)`
Removes the mapping for a key from this map if it is present (optional operation).
`boolean`
`retainEntries(TObjectCharProcedure<? super K> procedure)`
Retains only those entries in the map for which the procedure returns a true value.
`int`
`size()`
Returns the number of key-value mappings in this map.
`void`
`transformValues(TCharFunction function)`
Transform the values in this map using `function`.
`TCharCollection`
`valueCollection()`
Returns a `TCharCollection` view of the values contained in this map.
`char[]`
`values()`
Returns the values of the map as an array of `char` values.
`char[]`
`values(char[] array)`
Returns the values of the map using an existing array.

## Method Details

### getNoEntryValue

char getNoEntryValue()
Returns the value that will be returned from `get(java.lang.Object)` or `put(K, char)` 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.

### size

int size()
Returns the number of key-value mappings in this map. If the map contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`.

Returns:
  the number of key-value mappings in this map

### isEmpty

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

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

### containsKey

boolean containsKey(Object key)
Returns `true` if this map contains a mapping for the specified key. More formally, returns `true` if and only if this map contains a mapping for a key `k` such that `(key==null ? k==null : key.equals(k))`. (There can be at most one such mapping.)

Parameters:
  `key` - key whose presence in this map is to be tested
Returns:
  `true` if this map contains a mapping for the specified key
Throws:
  `ClassCastException` - if the key is of an inappropriate type for this map (optional)
  `NullPointerException` - if the specified key is null and this map does not permit null keys (optional)

### containsValue

boolean containsValue(char value)
Returns `true` if this map maps one or more keys to the specified value. More formally, returns `true` if and only if this map contains at least one mapping to a value `v` such that `(value==no_entry_value ? v==no_entry_value : value.equals(v))`. This operation will probably require time linear in the map size for most implementations of the `Map` interface.

Note that no_entry_value is the result of `getNoEntryValue()` and represents null for this map instance.

Parameters:
  `value` - `char` value whose presence in this map is to be tested
Returns:
  `true` if this map maps one or more keys to the specified value
Throws:
  `ClassCastException` - if the value is of an inappropriate type for this map (optional)
  `NullPointerException` - if the specified value is null and this map does not permit null values (optional)

### get

char get(Object key)
Returns the value to which the specified key is mapped, or `null` if this map contains no mapping for the key.

More formally, if this map contains a mapping from a key `k` to a value `v` such that `(key==null ? k==null : key.equals(k))`, then this method returns `v`; otherwise it returns `null`. (There can be at most one such mapping.)

If this map permits null values, then a return value of `null` does not necessarily indicate that the map contains no mapping for the key; it's also possible that the map explicitly maps the key to `null`. The `containsKey` operation may be used to distinguish these two cases.

Parameters:
  `key` - the key whose associated value is to be returned
Returns:
  the `char` value to which the specified key is mapped, or `null` if this map contains no mapping for the key
Throws:
  `ClassCastException` - if the key is of an inappropriate type for this map (optional)
  `NullPointerException` - if the specified key is null and this map does not permit null keys (optional)

### put

char put(K key, char value)
Associates the specified value with the specified key in this map (optional operation). If the map previously contained a mapping for the key, the old value is replaced by the specified value. (A map `m` is said to contain a mapping for a key `k` if and only if `m.containsKey(k)` would return `true`.)

Parameters:
  `key` - key with which the specified value is to be associated
  `value` - an `char` value value to be associated with the specified key
Returns:
  the previous value associated with `key`, or `no_entry_value` if there was no mapping for `key`. (A `no_entry_value` return can also indicate that the map previously associated `null` with `key`, if the implementation supports `null` values.)
Throws:
  `UnsupportedOperationException` - if the `put` operation is not supported by this map
  `ClassCastException` - if the class of the specified key or value prevents it from being stored in this map
  `NullPointerException` - if the specified key or value is null and this map does not permit null keys or values
  `IllegalArgumentException` - if some property of the specified key or value prevents it from being stored in this map
See Also:
  - `getNoEntryValue()`

### putIfAbsent

char putIfAbsent(K key, char value)
Inserts a key/value pair into the map if the specified key is not already associated with a value.

Parameters:
  `key` - key with which the specified value is to be associated
  `value` - an `char` value to be associated with the specified key
Returns:
  the previous value associated with `key`, or the "no entry" value if none was found (see `getNoEntryValue()`).

### remove

char remove(Object key)
Removes the mapping for a key from this map if it is present (optional operation). More formally, if this map contains a mapping from key `k` to value `v` such that `(key==null ? k==null : key.equals(k))`, that mapping is removed. (The map can contain at most one such mapping.)

Returns the value to which this map previously associated the key, or `null` if the map contained no mapping for the key.

If this map permits null values, then a return value of `null` does not necessarily indicate that the map contained no mapping for the key; it's also possible that the map explicitly mapped the key to `null`.

The map will not contain a mapping for the specified key once the call returns.

Parameters:
  `key` - key whose mapping is to be removed from the map
Returns:
  the previous `char` value associated with `key`, or `null` if there was no mapping for `key`.
Throws:
  `UnsupportedOperationException` - if the `remove` operation is not supported by this map
  `ClassCastException` - if the key is of an inappropriate type for this map (optional)
  `NullPointerException` - if the specified key is null and this map does not permit null keys (optional)

### putAll

void putAll(Map<? extends K,? extends Character> m)
Copies all of the mappings from the specified map to this map (optional operation). The effect of this call is equivalent to that of calling `put(k, v)` on this map once for each mapping from key `k` to value `v` in the specified map. The behavior of this operation is undefined if the specified map is modified while the operation is in progress.

Parameters:
  `m` - mappings to be stored in this map
Throws:
  `UnsupportedOperationException` - if the `putAll` operation is not supported by this map
  `ClassCastException` - if the class of a key or value in the specified map prevents it from being stored in this map
  `NullPointerException` - if the specified map is null, or if this map does not permit null keys or values, and the specified map contains null keys or values
  `IllegalArgumentException` - if some property of a key or value in the specified map prevents it from being stored in this map

### putAll

void putAll(TObjectCharMap<? extends K> 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.

### clear

void clear()
Removes all of the mappings from this map (optional operation). The map will be empty after this call returns.

Throws:
  `UnsupportedOperationException` - if the `clear` operation is not supported by this map

### keySet

Set<K> keySet()
Returns a `Set` view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the `Iterator.remove`, `Set.remove`, `removeAll`, `retainAll`, and `clear` operations. It does not support the `add` or `addAll` operations.

Returns:
  a set view of the keys contained in this map

### keys

Object[] keys()
Returns a copy of the keys of the map as an array. Changes to the array of keys will not be reflected in the map nor vice-versa.

Returns:
  a copy of the keys of the map as an array.

### keys

K[] keys(K[] array)
Returns a copy of the keys of the map as an array. Changes to the array of keys will not be reflected in the map nor vice-versa.

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

TCharCollection valueCollection()
Returns a `TCharCollection` view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator's own `remove` operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the `TCharIterator.remove`, `TCharCollection.remove`, `removeAll`, `retainAll` and `clear` operations. It does not support the `add` or `addAll` operations.

Returns:
  a collection view of the values contained in this map

### values

char[] values()
Returns the values of the map as an array of `char` values. Changes to the array of values will not be reflected in the map nor vice-versa.

Returns:
  the values of the map as an array of `char` values.

### values

char[] values(char[] array)
Returns the values of the map using an existing array. Changes to the array of values will not be reflected in the map nor vice-versa.

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 `char` values.

### iterator

TObjectCharIterator<K> iterator()
Returns a `TObjectCharIterator` with access to this map's keys and values.

Returns:
  a `TObjectCharIterator` with access to this map's keys and values.

### increment

boolean increment(K 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(K key, char 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

char adjustOrPutValue(K key, char adjust_amount, char 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

### forEachKey

boolean forEachKey(TObjectProcedure<? super K> procedure)
Executes `procedure` for each key in the map.

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

### forEachValue

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

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

### forEachEntry

boolean forEachEntry(TObjectCharProcedure<? super K> procedure)
Executes `procedure` for each key/value entry in the map.

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

### transformValues

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

Parameters:
  `function` - a `TCharFunction` value

### retainEntries

boolean retainEntries(TObjectCharProcedure<? super K> 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.

### equals

boolean equals(Object o)
Compares the specified object with this map for equality. Returns `true` if the given object is also a map and the two maps represent the same mappings. More formally, two maps `m1` and `m2` represent the same mappings if `m1.entrySet().equals(m2.entrySet())`. This ensures that the `equals` method works properly across different implementations of the `Map` interface.

Overrides:
  `equals` in class `Object`
Parameters:
  `o` - object to be compared for equality with this map
Returns:
  `true` if the specified object is equal to this map

### hashCode

int hashCode()
Returns the hash code value for this map. The hash code of a map is defined to be the sum of the hash codes of each entry in the map's `entrySet()` view. This ensures that `m1.equals(m2)` implies that `m1.hashCode()==m2.hashCode()` for any two maps `m1` and `m2`, as required by the general contract of `Object.hashCode()`.

Overrides:
  `hashCode` in class `Object`
Returns:
  the hash code value for this map
See Also:
  - `Object.equals(Object)`
  - `equals(Object)`