public static class Double2CharMaps.SynchronizedMap extends Double2CharFunctions.SynchronizedFunction implements Double2CharMap, Serializable
Double2CharMap.Entry, Double2CharMap.FastEntrySet| Modifier and Type | Method and Description |
|---|---|
char |
compute(double key,
BiFunction<? super Double,? super Character,? extends Character> remappingFunction)
Attempts to compute a mapping for the specified key and its current
mapped value (or
null if there is no current mapping). |
Character |
compute(Double key,
BiFunction<? super Double,? super Character,? extends Character> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
char |
computeIfAbsent(double key,
DoubleToIntFunction mappingFunction)
If the specified key is not already associated with a value, attempts to
compute its value using the given mapping function and enters it into
this map.
|
Character |
computeIfAbsent(Double key,
Function<? super Double,? extends Character> mappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
char |
computeIfAbsentNullable(double key,
DoubleFunction<? extends Character> mappingFunction)
If the specified key is not already associated with a value, attempts to
compute its value using the given mapping function and enters it into
this map unless it is
null. |
char |
computeIfAbsentPartial(double key,
Double2CharFunction mappingFunction)
If the specified key is not already associated with a value, attempts to
compute its value using the given mapping function and enters it into
this map, unless the key is not present in the given mapping function.
|
char |
computeIfPresent(double key,
BiFunction<? super Double,? super Character,? extends Character> remappingFunction)
If the value for the specified key is present, attempts to compute a new
mapping given the key and its current mapped value.
|
Character |
computeIfPresent(Double key,
BiFunction<? super Double,? super Character,? extends Character> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
containsValue(char v)
Returns
true if this map maps one or more keys to the specified
value. |
boolean |
containsValue(Object ov)
Deprecated.
Please use the corresponding type-specific method
instead.
|
ObjectSet<Double2CharMap.Entry> |
double2CharEntrySet()
Returns a type-specific set view of the mappings contained in this map.
|
ObjectSet<Map.Entry<Double,Character>> |
entrySet()
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
equals(Object o)
Indicates whether some other object is "equal to" this one.
|
void |
forEach(BiConsumer<? super Double,? super Character> action)
Performs the given action for each entry in this map until all entries
have been processed or the action throws an exception.
|
char |
getOrDefault(double key,
char defaultValue)
Returns the value to which the specified key is mapped, or the
defaultValue if this map contains no mapping for the key. |
Character |
getOrDefault(Object key,
Character defaultValue)
Deprecated.
Please use the corresponding type-specific method
instead.
|
int |
hashCode()
Returns a hash code value for the object.
|
boolean |
isEmpty()
Returns true if this map contains no key-value mappings.
|
DoubleSet |
keySet()
Returns a
Set view of the keys contained in this map. |
Character |
merge(Double key,
Character value,
BiFunction<? super Character,? super Character,? extends Character> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
char |
merge(double key,
char value,
BiFunction<? super Character,? super Character,? extends Character> remappingFunction)
If the specified key is not already associated with a value, associates
it with the given
value. |
void |
putAll(Map<? extends Double,? extends Character> m)
Copies all of the mappings from the specified map to this map
(optional operation).
|
char |
putIfAbsent(double key,
char value)
If the specified key is not already associated with a value, associates
it with the given value and returns the default return value, else returns the current value.
|
Character |
putIfAbsent(Double key,
Character value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
remove(double key,
char value)
Removes the entry for the specified key only if it is currently mapped to
the specified value.
|
boolean |
remove(Object key,
Object value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
char |
replace(double key,
char value)
Replaces the entry for the specified key only if it is currently mapped
to some value.
|
Character |
replace(Double key,
Character value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
replace(Double key,
Character oldValue,
Character newValue)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
replace(double key,
char oldValue,
char newValue)
Replaces the entry for the specified key only if currently mapped to the
specified value.
|
void |
replaceAll(BiFunction<? super Double,? super Character,? extends Character> function)
Replaces each entry's value with the result of invoking the given
function on that entry until all entries have been processed or the
function throws an exception.
|
CharCollection |
values()
Returns a
Collection view of the values contained in this map. |
apply, applyAsInt, clear, containsKey, containsKey, defaultReturnValue, defaultReturnValue, get, get, put, put, remove, remove, size, toStringclear, containsKey, containsKey, defaultReturnValue, defaultReturnValue, get, put, remove, sizeapplyAsInt, get, put, removepublic boolean containsValue(char v)
Double2CharMaptrue if this map maps one or more keys to the specified
value.containsValue in interface Double2CharMapMap.containsValue(Object)@Deprecated public boolean containsValue(Object ov)
containsValue in interface Double2CharMapcontainsValue in interface Map<Double,Character>ov - value whose presence in this map is to be testedpublic void putAll(Map<? extends Double,? extends Character> m)
java.util.Mapput(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.public ObjectSet<Double2CharMap.Entry> double2CharEntrySet()
Double2CharMap
This method is necessary because there is no inheritance along type
parameters: it is thus impossible to strengthen Map.entrySet() so
that it returns an ObjectSet of
type-specific entries (the latter makes it possible to access keys and
values with type-specific methods).
double2CharEntrySet in interface Double2CharMapMap.entrySet()@Deprecated public ObjectSet<Map.Entry<Double,Character>> entrySet()
Note that this specification strengthens the one given in
Map.entrySet().
entrySet in interface Double2CharMapentrySet in interface Map<Double,Character>Map.entrySet()public DoubleSet keySet()
Double2CharMapSet 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.
Note that this specification strengthens the one given in
Map.keySet().
keySet in interface Double2CharMapkeySet in interface Map<Double,Character>Map.keySet()public CharCollection values()
Double2CharMapCollection 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 Iterator.remove,
Collection.remove, removeAll,
retainAll and clear operations. It does not
support the add or addAll operations.
Note that this specification strengthens the one given in
Map.values().
values in interface Double2CharMapvalues in interface Map<Double,Character>Map.values()public boolean isEmpty()
java.util.Mappublic int hashCode()
java.lang.ObjectHashMap.
The general contract of hashCode is:
hashCode method
must consistently return the same integer, provided no information
used in equals comparisons on the object is modified.
This integer need not remain consistent from one execution of an
application to another execution of the same application.
equals(Object)
method, then calling the hashCode method on each of
the two objects must produce the same integer result.
Object.equals(java.lang.Object)
method, then calling the hashCode method on each of the
two objects must produce distinct integer results. However, the
programmer should be aware that producing distinct integer results
for unequal objects may improve the performance of hash tables.
As much as is reasonably practical, the hashCode method defined by
class Object does return distinct integers for distinct
objects. (This is typically implemented by converting the internal
address of the object into an integer, but this implementation
technique is not required by the
Java™ programming language.)
hashCode in interface Map<Double,Character>hashCode in class Double2CharFunctions.SynchronizedFunctionObject.equals(java.lang.Object),
System.identityHashCode(java.lang.Object)public boolean equals(Object o)
java.lang.Object
The equals method implements an equivalence relation
on non-null object references:
x, x.equals(x) should return
true.
x and y, x.equals(y)
should return true if and only if
y.equals(x) returns true.
x, y, and z, if
x.equals(y) returns true and
y.equals(z) returns true, then
x.equals(z) should return true.
x and y, multiple invocations of
x.equals(y) consistently return true
or consistently return false, provided no
information used in equals comparisons on the
objects is modified.
x,
x.equals(null) should return false.
The equals method for class Object implements
the most discriminating possible equivalence relation on objects;
that is, for any non-null reference values x and
y, this method returns true if and only
if x and y refer to the same object
(x == y has the value true).
Note that it is generally necessary to override the hashCode
method whenever this method is overridden, so as to maintain the
general contract for the hashCode method, which states
that equal objects must have equal hash codes.
equals in interface Map<Double,Character>equals in class Double2CharFunctions.SynchronizedFunctiono - the reference object with which to compare.true if this object is the same as the obj
argument; false otherwise.Object.hashCode(),
HashMappublic char getOrDefault(double key,
char defaultValue)
Double2CharMapdefaultValue if this map contains no mapping for the key.getOrDefault in interface Double2CharMapkey - the key.defaultValue - the default mapping of the key.defaultValue if this map contains no mapping for the key.Map.getOrDefault(Object, Object)public void forEach(BiConsumer<? super Double,? super Character> action)
java.util.Mappublic void replaceAll(BiFunction<? super Double,? super Character,? extends Character> function)
java.util.MapreplaceAll in interface Map<Double,Character>function - the function to apply to each entrypublic char putIfAbsent(double key,
char value)
Double2CharMapputIfAbsent in interface Double2CharMapkey - key with which the specified value is to be associated.value - value to be associated with the specified key.Map.putIfAbsent(Object, Object)public boolean remove(double key,
char value)
Double2CharMapremove in interface Double2CharMapkey - key with which the specified value is associated.value - value expected to be associated with the specified key.true if the value was removed.Map.remove(Object, Object)public char replace(double key,
char value)
Double2CharMapreplace in interface Double2CharMapkey - key with which the specified value is associated.value - value to be associated with the specified key.Map.replace(Object, Object)public boolean replace(double key,
char oldValue,
char newValue)
Double2CharMapreplace in interface Double2CharMapkey - key with which the specified value is associated.oldValue - value expected to be associated with the specified key.newValue - value to be associated with the specified key.true if the value was replaced.Map.replace(Object, Object, Object)public char computeIfAbsent(double key,
DoubleToIntFunction mappingFunction)
Double2CharMap
Note that contrarily to the default
computeIfAbsent(), it is not possible to not add a value for a given
key, since the mappingFunction cannot return null. If
such a behavior is needed, please use the corresponding nullable
version.
computeIfAbsent in interface Double2CharMapkey - key with which the specified value is to be associated.mappingFunction - the function to compute a value.Map.computeIfAbsent(Object, java.util.function.Function)public char computeIfAbsentNullable(double key,
DoubleFunction<? extends Character> mappingFunction)
Double2CharMapnull.
Note that this version of
computeIfAbsent() should be used only if you plan to return null
in the mapping function.
computeIfAbsentNullable in interface Double2CharMapkey - key with which the specified value is to be associated.mappingFunction - the function to compute a value.null.Map.computeIfAbsent(Object, java.util.function.Function)public char computeIfAbsentPartial(double key,
Double2CharFunction mappingFunction)
Double2CharMap
This version of
computeIfAbsent() uses a type-specific version of
fastutil's Function.
Since Function has a
containsKey()
method, it is possible to avoid adding a key by having
containsKey() return false for that key.
computeIfAbsentPartial in interface Double2CharMapkey - key with which the specified value is to be associated.mappingFunction - the function to compute a value.Map.computeIfAbsent(Object, java.util.function.Function)public char computeIfPresent(double key,
BiFunction<? super Double,? super Character,? extends Character> remappingFunction)
Double2CharMapcomputeIfPresent in interface Double2CharMapkey - key with which the specified value is to be associated.remappingFunction - the function to compute a value.Map.computeIfPresent(Object,
java.util.function.BiFunction)public char compute(double key,
BiFunction<? super Double,? super Character,? extends Character> remappingFunction)
Double2CharMapnull if there is no current mapping).
If the function returns null, the mapping is removed (or remains
absent if initially absent). If the function itself throws an (unchecked)
exception, the exception is rethrown, and the current mapping is left
unchanged.
compute in interface Double2CharMapkey - key with which the specified value is to be associated.remappingFunction - the function to compute a value.Map.compute(Object, java.util.function.BiFunction)public char merge(double key,
char value,
BiFunction<? super Character,? super Character,? extends Character> remappingFunction)
Double2CharMapvalue. Otherwise, replaces the associated value
with the results of the given remapping function, or removes if the
result is null.merge in interface Double2CharMapkey - key with which the resulting value is to be associated.value - the value to be merged with the existing value associated with
the key or, if no existing value is associated with the key,
to be associated with the key.remappingFunction - the function to recompute a value if present.Map.merge(Object, Object, java.util.function.BiFunction)@Deprecated public Character getOrDefault(Object key, Character defaultValue)
defaultValue if this map contains no mapping for the key.
This default implementation just delegates to the corresponding
Map method.
getOrDefault in interface Double2CharMapgetOrDefault in interface Map<Double,Character>key - the key whose associated value is to be returneddefaultValue - the default mapping of the keydefaultValue if this map contains no mapping for the key@Deprecated public boolean remove(Object key, Object value)
This default implementation just delegates to the corresponding
Map method.
@Deprecated public Character replace(Double key, Character value)
This default implementation just delegates to the corresponding
Map method.
replace in interface Double2CharMapreplace in interface Map<Double,Character>key - key with which the specified value is associatedvalue - value to be associated with the specified keynull if there was no mapping for the key.
(A null return can also indicate that the map
previously associated null with the key,
if the implementation supports null values.)@Deprecated public boolean replace(Double key, Character oldValue, Character newValue)
This default implementation just delegates to the corresponding
Map method.
replace in interface Double2CharMapreplace in interface Map<Double,Character>key - key with which the specified value is associatedoldValue - value expected to be associated with the specified keynewValue - value to be associated with the specified keytrue if the value was replaced@Deprecated public Character putIfAbsent(Double key, Character value)
null) associates it with the given value and returns
null, else returns the current value.
This default implementation just delegates to the corresponding
Map method.
putIfAbsent in interface Double2CharMapputIfAbsent in interface Map<Double,Character>key - key with which the specified value is to be associatedvalue - value to be associated with the specified keynull if there was no mapping for the key.
(A null return can also indicate that the map
previously associated null with the key,
if the implementation supports null values.)@Deprecated public Character computeIfAbsent(Double key, Function<? super Double,? extends Character> mappingFunction)
null), attempts to compute its value using the given mapping
function and enters it into this map unless null.
If the function returns null no mapping is recorded. If
the function itself throws an (unchecked) exception, the
exception is rethrown, and no mapping is recorded. The most
common usage is to construct a new object serving as an initial
mapped value or memoized result, as in:
map.computeIfAbsent(key, k -> new Value(f(k)));
Or to implement a multi-value map, Map<K,Collection<V>>,
supporting multiple values per key:
map.computeIfAbsent(key, k -> new HashSet<V>()).add(v);
This default implementation just delegates to the corresponding
Map method.
computeIfAbsent in interface Double2CharMapcomputeIfAbsent in interface Map<Double,Character>key - key with which the specified value is to be associatedmappingFunction - the function to compute a value@Deprecated public Character computeIfPresent(Double key, BiFunction<? super Double,? super Character,? extends Character> remappingFunction)
If the function returns null, the mapping is removed. If the
function itself throws an (unchecked) exception, the exception is
rethrown, and the current mapping is left unchanged.
This default implementation just delegates to the corresponding
Map method.
computeIfPresent in interface Double2CharMapcomputeIfPresent in interface Map<Double,Character>key - key with which the specified value is to be associatedremappingFunction - the function to compute a value@Deprecated public Character compute(Double key, BiFunction<? super Double,? super Character,? extends Character> remappingFunction)
null if there is no current mapping). For
example, to either create or append a String msg to a value
mapping:
map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))
(Method merge() is often simpler to use for such purposes.)
If the function returns null, the mapping is removed (or
remains absent if initially absent). If the function itself throws an
(unchecked) exception, the exception is rethrown, and the current mapping
is left unchanged.
This default implementation just delegates to the corresponding
Map method.
compute in interface Double2CharMapcompute in interface Map<Double,Character>key - key with which the specified value is to be associatedremappingFunction - the function to compute a value@Deprecated public Character merge(Double key, Character value, BiFunction<? super Character,? super Character,? extends Character> remappingFunction)
null. This
method may be of use when combining multiple mapped values for a key.
For example, to either create or append a String msg to a
value mapping:
map.merge(key, msg, String::concat)
If the function returns null the mapping is removed. If the
function itself throws an (unchecked) exception, the exception is
rethrown, and the current mapping is left unchanged.
This default implementation just delegates to the corresponding
Map method.
merge in interface Double2CharMapmerge in interface Map<Double,Character>key - key with which the resulting value is to be associatedvalue - the non-null value to be merged with the existing value
associated with the key or, if no existing value or a null value
is associated with the key, to be associated with the keyremappingFunction - the function to recompute a value if present