public static class Float2LongMaps.SynchronizedMap extends Float2LongFunctions.SynchronizedFunction implements Float2LongMap, Serializable
Float2LongMap.Entry, Float2LongMap.FastEntrySet| Modifier and Type | Method and Description |
|---|---|
long |
compute(float key,
BiFunction<? super Float,? super Long,? extends Long> remappingFunction)
Attempts to compute a mapping for the specified key and its current
mapped value (or
null if there is no current mapping). |
Long |
compute(Float key,
BiFunction<? super Float,? super Long,? extends Long> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
long |
computeIfAbsent(float key,
DoubleToLongFunction 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.
|
Long |
computeIfAbsent(Float key,
Function<? super Float,? extends Long> mappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
long |
computeIfAbsentNullable(float key,
DoubleFunction<? extends Long> 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. |
long |
computeIfAbsentPartial(float key,
Float2LongFunction 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.
|
long |
computeIfPresent(float key,
BiFunction<? super Float,? super Long,? extends Long> remappingFunction)
If the value for the specified key is present, attempts to compute a new
mapping given the key and its current mapped value.
|
Long |
computeIfPresent(Float key,
BiFunction<? super Float,? super Long,? extends Long> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
containsValue(long 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<Map.Entry<Float,Long>> |
entrySet()
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
equals(Object o)
Indicates whether some other object is "equal to" this one.
|
ObjectSet<Float2LongMap.Entry> |
float2LongEntrySet()
Returns a type-specific set view of the mappings contained in this map.
|
void |
forEach(BiConsumer<? super Float,? super Long> action)
Performs the given action for each entry in this map until all entries
have been processed or the action throws an exception.
|
long |
getOrDefault(float key,
long defaultValue)
Returns the value to which the specified key is mapped, or the
defaultValue if this map contains no mapping for the key. |
Long |
getOrDefault(Object key,
Long 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.
|
FloatSet |
keySet()
Returns a
Set view of the keys contained in this map. |
long |
merge(float key,
long value,
BiFunction<? super Long,? super Long,? extends Long> remappingFunction)
If the specified key is not already associated with a value, associates
it with the given
value. |
Long |
merge(Float key,
Long value,
BiFunction<? super Long,? super Long,? extends Long> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
void |
putAll(Map<? extends Float,? extends Long> m)
Copies all of the mappings from the specified map to this map
(optional operation).
|
long |
putIfAbsent(float key,
long 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.
|
Long |
putIfAbsent(Float key,
Long value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
remove(float key,
long 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.
|
long |
replace(float key,
long value)
Replaces the entry for the specified key only if it is currently mapped
to some value.
|
Long |
replace(Float key,
Long value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
replace(float key,
long oldValue,
long newValue)
Replaces the entry for the specified key only if currently mapped to the
specified value.
|
boolean |
replace(Float key,
Long oldValue,
Long newValue)
Deprecated.
Please use the corresponding type-specific method
instead.
|
void |
replaceAll(BiFunction<? super Float,? super Long,? extends Long> 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.
|
LongCollection |
values()
Returns a
Collection view of the values contained in this map. |
apply, applyAsLong, clear, containsKey, containsKey, defaultReturnValue, defaultReturnValue, get, get, put, put, remove, remove, size, toStringclear, containsKey, containsKey, defaultReturnValue, defaultReturnValue, get, put, remove, sizeapplyAsLong, get, put, removepublic boolean containsValue(long v)
Float2LongMaptrue if this map maps one or more keys to the specified
value.containsValue in interface Float2LongMapMap.containsValue(Object)@Deprecated public boolean containsValue(Object ov)
containsValue in interface Float2LongMapcontainsValue in interface Map<Float,Long>ov - value whose presence in this map is to be testedpublic void putAll(Map<? extends Float,? extends Long> 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<Float2LongMap.Entry> float2LongEntrySet()
Float2LongMap
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).
float2LongEntrySet in interface Float2LongMapMap.entrySet()@Deprecated public ObjectSet<Map.Entry<Float,Long>> entrySet()
Note that this specification strengthens the one given in
Map.entrySet().
entrySet in interface Float2LongMapentrySet in interface Map<Float,Long>Map.entrySet()public FloatSet keySet()
Float2LongMapSet 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 Float2LongMapkeySet in interface Map<Float,Long>Map.keySet()public LongCollection values()
Float2LongMapCollection 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 Float2LongMapvalues in interface Map<Float,Long>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<Float,Long>hashCode in class Float2LongFunctions.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<Float,Long>equals in class Float2LongFunctions.SynchronizedFunctiono - the reference object with which to compare.true if this object is the same as the obj
argument; false otherwise.Object.hashCode(),
HashMappublic long getOrDefault(float key,
long defaultValue)
Float2LongMapdefaultValue if this map contains no mapping for the key.getOrDefault in interface Float2LongMapkey - 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 Float,? super Long> action)
java.util.Mappublic void replaceAll(BiFunction<? super Float,? super Long,? extends Long> function)
java.util.MapreplaceAll in interface Map<Float,Long>function - the function to apply to each entrypublic long putIfAbsent(float key,
long value)
Float2LongMapputIfAbsent in interface Float2LongMapkey - 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(float key,
long value)
Float2LongMapremove in interface Float2LongMapkey - 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 long replace(float key,
long value)
Float2LongMapreplace in interface Float2LongMapkey - key with which the specified value is associated.value - value to be associated with the specified key.Map.replace(Object, Object)public boolean replace(float key,
long oldValue,
long newValue)
Float2LongMapreplace in interface Float2LongMapkey - 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 long computeIfAbsent(float key,
DoubleToLongFunction mappingFunction)
Float2LongMap
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 Float2LongMapkey - 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 long computeIfAbsentNullable(float key,
DoubleFunction<? extends Long> mappingFunction)
Float2LongMapnull.
Note that this version of
computeIfAbsent() should be used only if you plan to return null
in the mapping function.
computeIfAbsentNullable in interface Float2LongMapkey - 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 long computeIfAbsentPartial(float key,
Float2LongFunction mappingFunction)
Float2LongMap
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 Float2LongMapkey - 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 long computeIfPresent(float key,
BiFunction<? super Float,? super Long,? extends Long> remappingFunction)
Float2LongMapcomputeIfPresent in interface Float2LongMapkey - 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 long compute(float key,
BiFunction<? super Float,? super Long,? extends Long> remappingFunction)
Float2LongMapnull 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 Float2LongMapkey - 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 long merge(float key,
long value,
BiFunction<? super Long,? super Long,? extends Long> remappingFunction)
Float2LongMapvalue. Otherwise, replaces the associated value
with the results of the given remapping function, or removes if the
result is null.merge in interface Float2LongMapkey - 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 Long getOrDefault(Object key, Long defaultValue)
defaultValue if this map contains no mapping for the key.
This default implementation just delegates to the corresponding
Map method.
getOrDefault in interface Float2LongMapgetOrDefault in interface Map<Float,Long>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 Long replace(Float key, Long value)
This default implementation just delegates to the corresponding
Map method.
replace in interface Float2LongMapreplace in interface Map<Float,Long>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(Float key, Long oldValue, Long newValue)
This default implementation just delegates to the corresponding
Map method.
replace in interface Float2LongMapreplace in interface Map<Float,Long>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 Long putIfAbsent(Float key, Long 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 Float2LongMapputIfAbsent in interface Map<Float,Long>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 Long computeIfAbsent(Float key, Function<? super Float,? extends Long> 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 Float2LongMapcomputeIfAbsent in interface Map<Float,Long>key - key with which the specified value is to be associatedmappingFunction - the function to compute a value@Deprecated public Long computeIfPresent(Float key, BiFunction<? super Float,? super Long,? extends Long> 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 Float2LongMapcomputeIfPresent in interface Map<Float,Long>key - key with which the specified value is to be associatedremappingFunction - the function to compute a value@Deprecated public Long compute(Float key, BiFunction<? super Float,? super Long,? extends Long> 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.
@Deprecated public Long merge(Float key, Long value, BiFunction<? super Long,? super Long,? extends Long> 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 Float2LongMapmerge in interface Map<Float,Long>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