public interface CharByteMap extends Map<Character,Byte>, Container
CharByteMapFactory
,
@KolobokeMap
Modifier and Type | Method and Description |
---|---|
byte |
addValue(char key,
byte addition)
Adds the given value
addition to the value associated with the specified key,
or to the default value if this map contains no mapping for
the key, and associates the resulting value with the key. |
byte |
addValue(char key,
byte addition,
byte initialValue)
Adds the given value
addition to the value associated with the specified key,
or the given initialValue if this map contains no mapping for the key, and associates
the resulting value with the key. |
Byte |
compute(Character key,
BiFunction<? super Character,? super Byte,? extends Byte> remappingFunction)
Deprecated.
Use specialization
compute(char, CharByteToByteFunction) instead |
byte |
compute(char key,
CharByteToByteFunction remappingFunction)
Attempts to compute a mapping for the specified key and its current mapped value
(or default
value if there is no current mapping).
|
Byte |
computeIfAbsent(Character key,
Function<? super Character,? extends Byte> mappingFunction)
Deprecated.
Use specialization
computeIfAbsent(char, CharToByteFunction) instead |
byte |
computeIfAbsent(char key,
CharToByteFunction 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 |
computeIfPresent(Character key,
BiFunction<? super Character,? super Byte,? extends Byte> remappingFunction)
Deprecated.
Use specialization
computeIfPresent(char, CharByteToByteFunction) instead |
byte |
computeIfPresent(char key,
CharByteToByteFunction remappingFunction)
If the value for the specified key is present,
attempts to compute a new mapping given the key and its current mapped value.
|
boolean |
containsKey(char key)
Returns
true if this map contains a mapping for the specified key. |
boolean |
containsKey(Object key)
Deprecated.
Use specialization
containsKey(char) instead |
boolean |
containsValue(byte value)
Returns
true if this map maps one or more keys to the specified value. |
boolean |
containsValue(Object value)
Deprecated.
Use specialization
containsValue(byte) instead |
CharByteCursor |
cursor()
Returns a new cursor over the entries of this map.
|
byte |
defaultValue()
Returns the default value of this map, which is used instead of
null
in primitive specialization methods, when the key is absent in the map. |
ObjSet<Map.Entry<Character,Byte>> |
entrySet() |
void |
forEach(BiConsumer<? super Character,? super Byte> action)
Deprecated.
Use specialization
forEach(CharByteConsumer) instead |
void |
forEach(CharByteConsumer action)
Performs the given
action on each entry in this map until all entries
have been processed or the action throws an Exception . |
boolean |
forEachWhile(CharBytePredicate predicate)
Checks the given
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or throws an Exception . |
byte |
get(char key)
Returns the value to which the specified key is mapped, or default
value if this map
contains no mapping for the key.
|
Byte |
get(Object key)
Deprecated.
Use specialization
get(char) instead |
byte |
getOrDefault(char key,
byte defaultValue)
Returns the value to which the specified key is mapped, or
defaultValue if this map
contains no mapping for the key. |
Byte |
getOrDefault(Object key,
Byte defaultValue)
Deprecated.
Use specialization
getOrDefault(char, byte) instead |
CharSet |
keySet() |
Byte |
merge(Character key,
Byte value,
BiFunction<? super Byte,? super Byte,? extends Byte> remappingFunction)
Deprecated.
Use specialization
merge(char, byte, ByteBinaryOperator) instead |
byte |
merge(char key,
byte value,
ByteBinaryOperator remappingFunction)
If the specified key is not already associated with a value, associates
it with the given value, otherwise, replaces the value with the results of the given
remapping function.
|
Byte |
put(Character key,
Byte value)
Deprecated.
Use specialization
put(char, byte) instead |
byte |
put(char key,
byte value)
Associates the specified value with the specified key in this map (optional operation).
|
Byte |
putIfAbsent(Character key,
Byte value)
Deprecated.
Use specialization
putIfAbsent(char, byte) instead |
byte |
putIfAbsent(char key,
byte value)
If the specified key is not already associated with a value, associates
it with the given value and returns default
value, else returns the current value.
|
byte |
remove(char key)
Removes the mapping for a key from this map if it is present (optional operation).
|
boolean |
remove(char key,
byte value)
Removes the entry for the specified key only if it is currently mapped to the specified
value.
|
Byte |
remove(Object key)
Deprecated.
Use specialization
remove(char) instead |
boolean |
remove(Object key,
Object value)
Deprecated.
Use specialization
remove(char, byte) instead |
boolean |
removeIf(CharBytePredicate filter)
Removes all of the entries of this collection that satisfy the given predicate.
|
Byte |
replace(Character key,
Byte value)
Deprecated.
Use specialization
replace(char, byte) instead |
boolean |
replace(Character key,
Byte oldValue,
Byte newValue)
Deprecated.
Use specialization
replace(char, byte, byte) instead |
byte |
replace(char key,
byte value)
Replaces the entry for the specified key only if it is currently mapped to some value.
|
boolean |
replace(char key,
byte oldValue,
byte newValue)
Replaces the entry for the specified key only if currently mapped to the specified value.
|
void |
replaceAll(BiFunction<? super Character,? super Byte,? extends Byte> function)
Deprecated.
Use specialization
replaceAll(CharByteToByteFunction) instead |
void |
replaceAll(CharByteToByteFunction function)
Replaces each entry's value with the result of invoking the given function on that entry,
in the order entries are returned by an entry set iterator, until all entries have been
processed or the function throws an exception.
|
ByteCollection |
values() |
clear, ensureCapacity, isEmpty, shrink, size, sizeAsLong
byte defaultValue()
null
in primitive specialization methods, when the key is absent in the map.CharByteMapFactory.withDefaultValue(byte)
@Deprecated boolean containsKey(Object key)
containsKey(char)
insteadcontainsKey
in interface Map<Character,Byte>
boolean containsKey(char key)
true
if this map contains a mapping for the specified key.key
- the char
key whose presence in this map is to be testedtrue
if this map contains a mapping for the specified key@Deprecated boolean containsValue(Object value)
containsValue(byte)
insteadcontainsValue
in interface Map<Character,Byte>
boolean containsValue(byte value)
true
if this map maps one or more keys to the specified value. This operation
will probably require time linear in the map size for most implementations
of the CharByteMap
interface.value
- the byte
value whose presence in this map is to be testedtrue
if this map maps one or more keys to the specified value@Nullable @Deprecated Byte get(Object key)
get(char)
insteadbyte get(char key)
key
- the key whose associated value is to be returned@Deprecated Byte getOrDefault(Object key, Byte defaultValue)
getOrDefault(char, byte)
insteadgetOrDefault
in interface Map<Character,Byte>
byte getOrDefault(char key, byte defaultValue)
defaultValue
if this map
contains no mapping for the key.key
- the key whose associated value is to be returneddefaultValue
- the value to return if the specified key
is absent in the mapdefaultValue
if this map contains no mapping for the key@Deprecated void forEach(@Nonnull BiConsumer<? super Character,? super Byte> action)
forEach(CharByteConsumer)
insteadvoid forEach(@Nonnull CharByteConsumer action)
action
on each entry in this map until all entries
have been processed or the action throws an Exception
.
Exceptions thrown by the action are relayed to the caller. The entries
will be processed in the same order as the entry set iterator unless that
order is unspecified in which case implementations may use an order which
differs from the entry set iterator.action
- The action to be performed for each entryboolean forEachWhile(@Nonnull CharBytePredicate predicate)
predicate
on each entry in this map until all entries
have been processed or the predicate returns false
for some entry,
or throws an Exception
. Exceptions thrown by the predicate are relayed to the caller.
The entries will be processed in the same order as the entry set iterator unless that order is unspecified in which case implementations may use an order which differs from the entry set iterator.
If the map is empty, this method returns true
immediately.
predicate
- the predicate to be checked for each entrytrue
if the predicate returned true
for all entries of the map,
false
if it returned false
for the entry@Nonnull CharByteCursor cursor()
Basic cursor usage idiom is:
for (CharByteCursor cur = map.cursor(); cur.moveNext();) {
// Work with cur.key() and cur.value()
// Call cur.remove() to remove the current entry
}
@Deprecated Byte put(Character key, Byte value)
put(char, byte)
insteadbyte put(char key, byte value)
m
is said to contain a mapping for a key k
if and only if m.containsKey(k)
would return true
.)key
- key with which the specified value is to be associatedvalue
- value to be associated with the specified keykey
, or default
value if there was
no mapping for key
. (A default
value return can also indicate that the map
previously associated default
value with key
.)UnsupportedOperationException
- if the put
operation
is not supported by this mapIllegalArgumentException
- if some property of a specified key
or value prevents it from being stored in this map@Nullable @Deprecated Byte putIfAbsent(Character key, Byte value)
putIfAbsent(char, byte)
insteadnull
, else returns the current value.putIfAbsent
in interface Map<Character,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.)UnsupportedOperationException
- if the put
operation
is not supported by this mapClassCastException
- if the key or value is of an inappropriate type for this mapNullPointerException
- if the specified key or value is nullIllegalArgumentException
- if some property of the specified key
or value prevents it from being stored in this mapbyte putIfAbsent(char key, byte value)
key
- key with which the specified value is to be associatedvalue
- value to be associated with the specified keyUnsupportedOperationException
- if the put
operation
is not supported by this mapIllegalArgumentException
- if some property of a specified key
or value prevents it from being stored in this map@Deprecated Byte compute(Character key, @Nonnull BiFunction<? super Character,? super Byte,? extends Byte> remappingFunction)
compute(char, CharByteToByteFunction)
insteadbyte compute(char key, @Nonnull CharByteToByteFunction remappingFunction)
If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.
key
- key with which the specified value is to be associatedremappingFunction
- the function to compute a valueUnsupportedOperationException
- if the put
operation
is not supported by this map@Deprecated Byte computeIfAbsent(Character key, @Nonnull Function<? super Character,? extends Byte> mappingFunction)
computeIfAbsent(char, CharToByteFunction)
insteadcomputeIfAbsent
in interface Map<Character,Byte>
byte computeIfAbsent(char key, @Nonnull CharToByteFunction mappingFunction)
If the function itself throws an (unchecked) exception, the exception is rethrown, and no mapping is recorded.
key
- key with which the specified value is to be associatedmappingFunction
- the function to compute a valueUnsupportedOperationException
- if the put
operation
is not supported by this map@Deprecated Byte computeIfPresent(Character key, @Nonnull BiFunction<? super Character,? super Byte,? extends Byte> remappingFunction)
computeIfPresent(char, CharByteToByteFunction)
insteadcomputeIfPresent
in interface Map<Character,Byte>
byte computeIfPresent(char key, @Nonnull CharByteToByteFunction remappingFunction)
If the function itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.
key
- key with which the specified value is to be associatedremappingFunction
- the function to compute a valueUnsupportedOperationException
- if the put
operation
is not supported by this map@Deprecated Byte merge(Character key, Byte value, @Nonnull BiFunction<? super Byte,? super Byte,? extends Byte> remappingFunction)
merge(char, byte, ByteBinaryOperator)
insteadbyte merge(char key, byte value, @Nonnull ByteBinaryOperator remappingFunction)
If the remappingFunction itself throws an (unchecked) exception, the exception is rethrown, and the current mapping is left unchanged.
key
- key with which the specified value is to be associatedvalue
- the value to use if absentremappingFunction
- the function to recompute a value if presentNullPointerException
- if the remappingFunction
is nullUnsupportedOperationException
- if the put
operation
is not supported by this mapbyte addValue(char key, byte addition)
addition
to the value associated with the specified key,
or to the default value if this map contains no mapping for
the key, and associates the resulting value with the key.key
- the key to which value add the given valueaddition
- the value additionUnsupportedOperationException
- if the put
operation
is not supported by this mapbyte addValue(char key, byte addition, byte initialValue)
addition
to the value associated with the specified key,
or the given initialValue
if this map contains no mapping for the key, and associates
the resulting value with the key.
This version of addValue(char, byte)
method is useful if you want
to accumulate values from the different initial value, than the default value of this map.
key
- the key to which value add the given valueaddition
- the value additioninitialValue
- the value to add the given value addition
to, if the map contains
no mapping for the given keyUnsupportedOperationException
- if the put
operation
is not supported by this map@Nullable @Deprecated Byte replace(Character key, Byte value)
replace(char, byte)
insteadreplace
in interface Map<Character,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.UnsupportedOperationException
- if the put
operation
is not supported by this mapNullPointerException
- if the specified key or value is nullIllegalArgumentException
- if some property of the specified value
prevents it from being stored in this mapbyte replace(char key, byte value)
key
- key with which the specified value is associatedvalue
- value to be associated with the specified keyIllegalArgumentException
- if some property of a specified key
or value prevents it from being stored in this mapUnsupportedOperationException
- if the put
operation
is not supported by this map@Deprecated boolean replace(Character key, Byte oldValue, Byte newValue)
replace(char, byte, byte)
insteadreplace
in interface Map<Character,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 replacedUnsupportedOperationException
- if the put
operation
is not supported by this mapNullPointerException
- if the specified key or value is nullIllegalArgumentException
- if some property of the specified value
prevents it from being stored in this mapboolean replace(char key, byte oldValue, byte newValue)
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 replacedIllegalArgumentException
- if some property of a specified key
or value prevents it from being stored in this mapUnsupportedOperationException
- if the put
operation
is not supported by this map@Deprecated void replaceAll(@Nonnull BiFunction<? super Character,? super Byte,? extends Byte> function)
replaceAll(CharByteToByteFunction)
insteadreplaceAll
in interface Map<Character,Byte>
void replaceAll(@Nonnull CharByteToByteFunction function)
function
- the function to apply to each entryUnsupportedOperationException
- if the set
operation
is not supported by this map's entry set iteratorIllegalArgumentException
- if some property of a replacement value
prevents it from being stored in this map (optional restriction)@Nullable @Deprecated Byte remove(Object key)
remove(char)
insteadbyte remove(char key)
Returns the value to which this map previously associated the key, or default value if the map contained no mapping for the key.
A return value of default value 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 default value.
The map will not contain a mapping for the specified key once the call returns.
key
- key whose mapping is to be removed from the mapkey
, or default
value if there was
no mapping for key
UnsupportedOperationException
- if the remove
operation
is not supported by this map@Deprecated boolean remove(Object key, Object value)
remove(char, byte)
insteadremove
in interface Map<Character,Byte>
key
- key with which the specified value is associatedvalue
- value expected to be associated with the specified keytrue
if the value was removedNullPointerException
- if the specified key or value is nullUnsupportedOperationException
- if the remove
operation
is not supported by this mapboolean remove(char key, byte value)
key
- key with which the specified value is associatedvalue
- value expected to be associated with the specified keytrue
if the value was removedUnsupportedOperationException
- if the remove
operation
is not supported by this mapboolean removeIf(@Nonnull CharBytePredicate filter)
filter
- a predicate which returns true
for elements to be removedtrue
if any elements were removedNullPointerException
- if the specified filter is nullUnsupportedOperationException
- if elements cannot be removed from this collection.
Implementations may throw this exception if a matching element cannot be removed
or if, in general, removal is not supported.