public static class Long2LongMaps.UnmodifiableMap extends Long2LongFunctions.UnmodifiableFunction implements Long2LongMap, Serializable
Long2LongMap.Entry, Long2LongMap.FastEntrySet| Modifier and Type | Method and Description |
|---|---|
long |
compute(long key,
BiFunction<? super Long,? 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(Long key,
BiFunction<? super Long,? super Long,? extends Long> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
Long |
computeIfAbsent(Long key,
Function<? super Long,? extends Long> mappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
long |
computeIfAbsent(long key,
LongUnaryOperator 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 |
computeIfAbsentNullable(long key,
LongFunction<? 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(long key,
Long2LongFunction 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(long key,
BiFunction<? super Long,? 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(Long key,
BiFunction<? super Long,? 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<Long,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.
|
void |
forEach(BiConsumer<? super Long,? 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(long 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.
|
LongSet |
keySet()
Returns a
Set view of the keys contained in this map. |
ObjectSet<Long2LongMap.Entry> |
long2LongEntrySet()
Returns a type-specific set view of the mappings contained in this map.
|
long |
merge(long 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(Long key,
Long value,
BiFunction<? super Long,? super Long,? extends Long> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
void |
putAll(Map<? extends Long,? extends Long> m)
Copies all of the mappings from the specified map to this map
(optional operation).
|
long |
putIfAbsent(long 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(Long key,
Long value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
remove(long 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(long key,
long value)
Replaces the entry for the specified key only if it is currently mapped
to some value.
|
Long |
replace(Long key,
Long value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
replace(long key,
long oldValue,
long newValue)
Replaces the entry for the specified key only if currently mapped to the
specified value.
|
boolean |
replace(Long key,
Long oldValue,
Long newValue)
Deprecated.
Please use the corresponding type-specific method
instead.
|
void |
replaceAll(BiFunction<? super Long,? 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. |
clear, containsKey, defaultReturnValue, defaultReturnValue, get, get, put, put, remove, remove, size, toStringclear, containsKey, containsKey, defaultReturnValue, defaultReturnValue, get, put, remove, sizeapplyAsLong, get, put, removeandThen, compose, identitypublic boolean containsValue(long v)
Long2LongMaptrue if this map maps one or more keys to the specified
value.containsValue in interface Long2LongMapMap.containsValue(Object)@Deprecated public boolean containsValue(Object ov)
containsValue in interface Long2LongMapcontainsValue in interface Map<Long,Long>ov - value whose presence in this map is to be testedpublic void putAll(Map<? extends Long,? 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<Long2LongMap.Entry> long2LongEntrySet()
Long2LongMap
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).
long2LongEntrySet in interface Long2LongMapMap.entrySet()@Deprecated public ObjectSet<Map.Entry<Long,Long>> entrySet()
Note that this specification strengthens the one given in
Map.entrySet().
entrySet in interface Long2LongMapentrySet in interface Map<Long,Long>Map.entrySet()public LongSet keySet()
Long2LongMapSet 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 Long2LongMapkeySet in interface Map<Long,Long>Map.keySet()public LongCollection values()
Long2LongMapCollection 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 Long2LongMapvalues in interface Map<Long,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<Long,Long>hashCode in class Long2LongFunctions.UnmodifiableFunctionObject.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<Long,Long>equals in class Long2LongFunctions.UnmodifiableFunctiono - 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(long key,
long defaultValue)
Long2LongMapdefaultValue if this map contains no mapping for the key.getOrDefault in interface Long2LongMapkey - 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 Long,? super Long> action)
java.util.Mappublic void replaceAll(BiFunction<? super Long,? super Long,? extends Long> function)
java.util.MapreplaceAll in interface Map<Long,Long>function - the function to apply to each entrypublic long putIfAbsent(long key,
long value)
Long2LongMapputIfAbsent in interface Long2LongMapkey - 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(long key,
long value)
Long2LongMapremove in interface Long2LongMapkey - 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(long key,
long value)
Long2LongMapreplace in interface Long2LongMapkey - key with which the specified value is associated.value - value to be associated with the specified key.Map.replace(Object, Object)public boolean replace(long key,
long oldValue,
long newValue)
Long2LongMapreplace in interface Long2LongMapkey - 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(long key,
LongUnaryOperator mappingFunction)
Long2LongMap
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 Long2LongMapkey - 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(long key,
LongFunction<? extends Long> mappingFunction)
Long2LongMapnull.
Note that this version of
computeIfAbsent() should be used only if you plan to return null
in the mapping function.
computeIfAbsentNullable in interface Long2LongMapkey - 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(long key,
Long2LongFunction mappingFunction)
Long2LongMap
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 Long2LongMapkey - 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(long key,
BiFunction<? super Long,? super Long,? extends Long> remappingFunction)
Long2LongMapcomputeIfPresent in interface Long2LongMapkey - 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(long key,
BiFunction<? super Long,? super Long,? extends Long> remappingFunction)
Long2LongMapnull 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 Long2LongMapkey - 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(long key,
long value,
BiFunction<? super Long,? super Long,? extends Long> remappingFunction)
Long2LongMapvalue. Otherwise, replaces the associated value
with the results of the given remapping function, or removes if the
result is null.merge in interface Long2LongMapkey - 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 Long2LongMapgetOrDefault in interface Map<Long,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(Long key, Long value)
This default implementation just delegates to the corresponding
Map method.
replace in interface Long2LongMapreplace in interface Map<Long,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(Long key, Long oldValue, Long newValue)
This default implementation just delegates to the corresponding
Map method.
replace in interface Long2LongMapreplace in interface Map<Long,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(Long 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 Long2LongMapputIfAbsent in interface Map<Long,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(Long key, Function<? super Long,? 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 Long2LongMapcomputeIfAbsent in interface Map<Long,Long>key - key with which the specified value is to be associatedmappingFunction - the function to compute a value@Deprecated public Long computeIfPresent(Long key, BiFunction<? super Long,? 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 Long2LongMapcomputeIfPresent in interface Map<Long,Long>key - key with which the specified value is to be associatedremappingFunction - the function to compute a value@Deprecated public Long compute(Long key, BiFunction<? super Long,? 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(Long 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 Long2LongMapmerge in interface Map<Long,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