public static class Int2ByteMaps.UnmodifiableMap extends Int2ByteFunctions.UnmodifiableFunction implements Int2ByteMap, Serializable
Int2ByteMap.Entry, Int2ByteMap.FastEntrySet| Modifier and Type | Method and Description |
|---|---|
byte |
compute(int key,
BiFunction<? super Integer,? super Byte,? extends Byte> remappingFunction)
Attempts to compute a mapping for the specified key and its current
mapped value (or
null if there is no current mapping). |
Byte |
compute(Integer key,
BiFunction<? super Integer,? super Byte,? extends Byte> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
Byte |
computeIfAbsent(Integer key,
Function<? super Integer,? extends Byte> mappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
byte |
computeIfAbsent(int key,
IntUnaryOperator 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.
|
byte |
computeIfAbsentNullable(int key,
IntFunction<? extends Byte> 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. |
byte |
computeIfAbsentPartial(int key,
Int2ByteFunction 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.
|
byte |
computeIfPresent(int key,
BiFunction<? super Integer,? super Byte,? extends Byte> remappingFunction)
If the value for the specified key is present, attempts to compute a new
mapping given the key and its current mapped value.
|
Byte |
computeIfPresent(Integer key,
BiFunction<? super Integer,? super Byte,? extends Byte> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
containsValue(byte 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<Integer,Byte>> |
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 Integer,? super Byte> action)
Performs the given action for each entry in this map until all entries
have been processed or the action throws an exception.
|
byte |
getOrDefault(int key,
byte defaultValue)
Returns the value to which the specified key is mapped, or the
defaultValue if this map contains no mapping for the key. |
Byte |
getOrDefault(Object key,
Byte defaultValue)
Deprecated.
Please use the corresponding type-specific method
instead.
|
int |
hashCode()
Returns a hash code value for the object.
|
ObjectSet<Int2ByteMap.Entry> |
int2ByteEntrySet()
Returns a type-specific set view of the mappings contained in this map.
|
boolean |
isEmpty()
Returns true if this map contains no key-value mappings.
|
IntSet |
keySet()
Returns a
Set view of the keys contained in this map. |
byte |
merge(int key,
byte value,
BiFunction<? super Byte,? super Byte,? extends Byte> remappingFunction)
If the specified key is not already associated with a value, associates
it with the given
value. |
Byte |
merge(Integer key,
Byte value,
BiFunction<? super Byte,? super Byte,? extends Byte> remappingFunction)
Deprecated.
Please use the corresponding type-specific method
instead.
|
void |
putAll(Map<? extends Integer,? extends Byte> m)
Copies all of the mappings from the specified map to this map
(optional operation).
|
byte |
putIfAbsent(int key,
byte 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.
|
Byte |
putIfAbsent(Integer key,
Byte value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
remove(int key,
byte 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.
|
byte |
replace(int key,
byte value)
Replaces the entry for the specified key only if it is currently mapped
to some value.
|
boolean |
replace(int key,
byte oldValue,
byte newValue)
Replaces the entry for the specified key only if currently mapped to the
specified value.
|
Byte |
replace(Integer key,
Byte value)
Deprecated.
Please use the corresponding type-specific method
instead.
|
boolean |
replace(Integer key,
Byte oldValue,
Byte newValue)
Deprecated.
Please use the corresponding type-specific method
instead.
|
void |
replaceAll(BiFunction<? super Integer,? super Byte,? extends Byte> 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.
|
ByteCollection |
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, sizeapplyAsInt, get, put, removeandThen, compose, identitypublic boolean containsValue(byte v)
Int2ByteMaptrue if this map maps one or more keys to the specified
value.containsValue in interface Int2ByteMapMap.containsValue(Object)@Deprecated public boolean containsValue(Object ov)
containsValue in interface Int2ByteMapcontainsValue in interface Map<Integer,Byte>ov - value whose presence in this map is to be testedpublic void putAll(Map<? extends Integer,? extends Byte> 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<Int2ByteMap.Entry> int2ByteEntrySet()
Int2ByteMap
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).
int2ByteEntrySet in interface Int2ByteMapMap.entrySet()@Deprecated public ObjectSet<Map.Entry<Integer,Byte>> entrySet()
Note that this specification strengthens the one given in
Map.entrySet().
entrySet in interface Int2ByteMapentrySet in interface Map<Integer,Byte>Map.entrySet()public IntSet keySet()
Int2ByteMapSet 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 Int2ByteMapkeySet in interface Map<Integer,Byte>Map.keySet()public ByteCollection values()
Int2ByteMapCollection 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 Int2ByteMapvalues in interface Map<Integer,Byte>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<Integer,Byte>hashCode in class Int2ByteFunctions.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<Integer,Byte>equals in class Int2ByteFunctions.UnmodifiableFunctiono - the reference object with which to compare.true if this object is the same as the obj
argument; false otherwise.Object.hashCode(),
HashMappublic byte getOrDefault(int key,
byte defaultValue)
Int2ByteMapdefaultValue if this map contains no mapping for the key.getOrDefault in interface Int2ByteMapkey - 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 Integer,? super Byte> action)
java.util.Mappublic void replaceAll(BiFunction<? super Integer,? super Byte,? extends Byte> function)
java.util.MapreplaceAll in interface Map<Integer,Byte>function - the function to apply to each entrypublic byte putIfAbsent(int key,
byte value)
Int2ByteMapputIfAbsent in interface Int2ByteMapkey - 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(int key,
byte value)
Int2ByteMapremove in interface Int2ByteMapkey - 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 byte replace(int key,
byte value)
Int2ByteMapreplace in interface Int2ByteMapkey - key with which the specified value is associated.value - value to be associated with the specified key.Map.replace(Object, Object)public boolean replace(int key,
byte oldValue,
byte newValue)
Int2ByteMapreplace in interface Int2ByteMapkey - 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 byte computeIfAbsent(int key,
IntUnaryOperator mappingFunction)
Int2ByteMap
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 Int2ByteMapkey - 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 byte computeIfAbsentNullable(int key,
IntFunction<? extends Byte> mappingFunction)
Int2ByteMapnull.
Note that this version of
computeIfAbsent() should be used only if you plan to return null
in the mapping function.
computeIfAbsentNullable in interface Int2ByteMapkey - 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 byte computeIfAbsentPartial(int key,
Int2ByteFunction mappingFunction)
Int2ByteMap
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 Int2ByteMapkey - 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 byte computeIfPresent(int key,
BiFunction<? super Integer,? super Byte,? extends Byte> remappingFunction)
Int2ByteMapcomputeIfPresent in interface Int2ByteMapkey - 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 byte compute(int key,
BiFunction<? super Integer,? super Byte,? extends Byte> remappingFunction)
Int2ByteMapnull 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 Int2ByteMapkey - 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 byte merge(int key,
byte value,
BiFunction<? super Byte,? super Byte,? extends Byte> remappingFunction)
Int2ByteMapvalue. Otherwise, replaces the associated value
with the results of the given remapping function, or removes if the
result is null.merge in interface Int2ByteMapkey - 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 Byte getOrDefault(Object key, Byte defaultValue)
defaultValue if this map contains no mapping for the key.
This default implementation just delegates to the corresponding
Map method.
getOrDefault in interface Int2ByteMapgetOrDefault in interface Map<Integer,Byte>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 Byte replace(Integer key, Byte value)
This default implementation just delegates to the corresponding
Map method.
replace in interface Int2ByteMapreplace in interface Map<Integer,Byte>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(Integer key, Byte oldValue, Byte newValue)
This default implementation just delegates to the corresponding
Map method.
replace in interface Int2ByteMapreplace in interface Map<Integer,Byte>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 Byte putIfAbsent(Integer key, Byte 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 Int2ByteMapputIfAbsent in interface Map<Integer,Byte>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 Byte computeIfAbsent(Integer key, Function<? super Integer,? extends Byte> 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 Int2ByteMapcomputeIfAbsent in interface Map<Integer,Byte>key - key with which the specified value is to be associatedmappingFunction - the function to compute a value@Deprecated public Byte computeIfPresent(Integer key, BiFunction<? super Integer,? super Byte,? extends Byte> 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 Int2ByteMapcomputeIfPresent in interface Map<Integer,Byte>key - key with which the specified value is to be associatedremappingFunction - the function to compute a value@Deprecated public Byte compute(Integer key, BiFunction<? super Integer,? super Byte,? extends Byte> 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 Byte merge(Integer key, Byte value, BiFunction<? super Byte,? super Byte,? extends Byte> 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 Int2ByteMapmerge in interface Map<Integer,Byte>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