public interface MutableFloatObjectMap<V> extends FloatObjectMap<V>, MutablePrimitiveObjectMap<V>
| Modifier and Type | Method and Description |
|---|---|
MutableFloatObjectMap<V> |
asSynchronized()
Returns a synchronized view of this map, delegating all operations to this map but
ensuring only one caller has access to the map at a time.
|
MutableFloatObjectMap<V> |
asUnmodifiable()
Returns an unmodifiable view of this map, delegating all read-only operations to this
map and throwing an
UnsupportedOperationException for all mutating operations. |
MutableObjectFloatMap<V> |
flipUniqueValues()
Return the ObjectFloatMap that is obtained by flipping the direction of this map and making the associations
from value to key.
|
V |
getIfAbsentPut(float key,
Function0<? extends V> function)
Retrieves the value associated with the key if one exists; if it does not,
invokes the supplier and associates the result with the key.
|
V |
getIfAbsentPut(float key,
V value)
Retrieves the value associated with the key if one exists; if it does not,
associates a value with the key.
|
<P> V |
getIfAbsentPutWith(float key,
Function<? super P,? extends V> function,
P parameter)
Retrieves the value associated with the key if one exists; if it does not,
invokes the value function with the parameter and associates the result with the key.
|
V |
getIfAbsentPutWithKey(float key,
FloatToObjectFunction<? extends V> function)
Retrieves the value associated with the key if one exists; if it does not,
associates the result of invoking the value function with the key.
|
V |
put(float key,
V value)
Associates a value with the specified key.
|
void |
putAll(FloatObjectMap<? extends V> map)
Puts all of the key/value mappings from the specified map into this map.
|
default V |
putPair(FloatObjectPair<V> keyValuePair)
This method allows MutableFloatObjectMap the ability to add an element in the form of
FloatObjectPair<V>. |
MutableFloatObjectMap<V> |
reject(FloatObjectPredicate<? super V> predicate)
Return a copy of this map containing only the key/value pairs that do not match the
predicate.
|
V |
remove(float key)
Removes the mapping associated with the key, if one exists, from the map.
|
V |
removeKey(float key)
Removes the mapping associated with the key, if one exists, from the map.
|
MutableFloatObjectMap<V> |
select(FloatObjectPredicate<? super V> predicate)
Return a copy of this map containing only the key/value pairs that match the predicate.
|
MutableFloatObjectMap<V> |
tap(Procedure<? super V> procedure)
Executes the Procedure for each element in the iterable and returns
this. |
V |
updateValue(float key,
Function0<? extends V> factory,
Function<? super V,? extends V> function)
Look up the value associated with
key, apply the function to it, and replace the value. |
<P> V |
updateValueWith(float key,
Function0<? extends V> factory,
Function2<? super V,? super P,? extends V> function,
P parameter)
Updates or sets the value associated with the key by applying the function to the
existing value, if one exists, or the initial value supplied by the factory if one does not.
|
default MutableFloatObjectMap<V> |
withAllKeyValues(Iterable<FloatObjectPair<V>> keyValuePairs)
Puts all of the key/value mappings from the specified pairs into this map.
|
MutableFloatObjectMap<V> |
withKeyValue(float key,
V value)
Associates a value with the specified key.
|
MutableFloatObjectMap<V> |
withoutAllKeys(FloatIterable keys)
Removes the mappings associated with all the keys, if they exist, from this map.
|
MutableFloatObjectMap<V> |
withoutKey(float key)
Removes the mapping associated with the key, if one exists, from this map.
|
containsKey, forEachKey, forEachKeyValue, get, getIfAbsent, keySet, keysView, keyValuesView, toImmutableaggregateBy, aggregateInPlaceBy, clear, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, flatCollect, flatCollectWith, groupBy, groupByEach, groupByUniqueKey, partition, partitionWith, reject, rejectWith, select, selectInstancesOf, selectWith, sumByDouble, sumByFloat, sumByInt, sumByLong, zip, zipWithIndexcontainsValue, equals, forEachValue, hashCode, parallelStream, spliterator, stream, toString, valuesaggregateBy, allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, containsBy, count, countBy, countBy, countByEach, countByEach, countByWith, countByWith, countWith, detect, detectIfNone, detectOptional, detectWith, detectWithIfNone, detectWithOptional, each, flatCollect, flatCollectBoolean, flatCollectByte, flatCollectChar, flatCollectDouble, flatCollectFloat, flatCollectInt, flatCollectLong, flatCollectShort, flatCollectWith, forEach, getAny, getFirst, getLast, getOnly, groupBy, groupByAndCollect, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, into, isEmpty, makeString, makeString, makeString, max, max, maxBy, maxByOptional, maxOptional, maxOptional, min, min, minBy, minByOptional, minOptional, minOptional, noneSatisfy, noneSatisfyWith, notEmpty, reduce, reduceInPlace, reduceInPlace, reject, rejectWith, select, selectWith, size, summarizeDouble, summarizeFloat, summarizeInt, summarizeLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toBiMap, toList, toMap, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedMapBy, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndexforEach, forEachWith, forEachWithIndexV put(float key, V value)
value.key - the keyvalue - the value to associate with valuekey if one existed, or
null if notdefault V putPair(FloatObjectPair<V> keyValuePair)
FloatObjectPair<V>.put(float, Object)void putAll(FloatObjectMap<? extends V> map)
map.map - the map to copy into this mapV removeKey(float key)
key - the key to removeremove(float)V remove(float key)
key - the key to removeremoveKey(float)V getIfAbsentPut(float key, V value)
key - the keyvalue - the value to associate with key if no such mapping existsvalue if notV getIfAbsentPut(float key, Function0<? extends V> function)
key - the keyfunction - the supplier that provides the value if no mapping exists for keyfunction if notV getIfAbsentPutWithKey(float key, FloatToObjectFunction<? extends V> function)
key - the keyfunction - the function that provides the value if no mapping exists.
The key will be passed as the argument to the function.function with key if not<P> V getIfAbsentPutWith(float key, Function<? super P,? extends V> function, P parameter)
P - the type of the value function's parameterkey - the keyfunction - the function that provides the value if no mapping exists.
The specified parameter will be passed as the argument to the function.parameter - the parameter to provide to function if no value
exists for keyfunction with parameter if notV updateValue(float key, Function0<? extends V> factory, Function<? super V,? extends V> function)
key, apply the function to it, and replace the value. If there
is no value associated with key, start it off with a value supplied by factory.<P> V updateValueWith(float key, Function0<? extends V> factory, Function2<? super V,? super P,? extends V> function, P parameter)
P - the type of the value function's parameterkey - the keyfactory - the supplier providing the initial value to the function if no
mapping exists for the keyfunction - the function that returns the updated value based on the current
value or the initial value, if no value exists. The specified parameter
will also be passed as the second argument to the function.parameter - the parameter to provide to function if no value
exists for keyfunction to the value already associated with the key or as a result of
applying it to the value returned by factory and associating the result
with keyMutableObjectFloatMap<V> flipUniqueValues()
FloatObjectMapflipUniqueValues in interface FloatObjectMap<V>MutableFloatObjectMap<V> tap(Procedure<? super V> procedure)
RichIterablethis.
Example using a Java 8 lambda expression:
RichIterable<Person> tapped =
people.tap(person -> LOGGER.info(person.getName()));
Example using an anonymous inner class:
RichIterable<Person> tapped =
people.tap(new Procedure<Person>()
{
public void value(Person person)
{
LOGGER.info(person.getName());
}
});
tap in interface FloatObjectMap<V>tap in interface RichIterable<V>RichIterable.each(Procedure),
RichIterable.forEach(Procedure)MutableFloatObjectMap<V> select(FloatObjectPredicate<? super V> predicate)
FloatObjectMapselect in interface FloatObjectMap<V>predicate - the predicate to determine which key/value pairs in this map should be
included in the returned mapMutableFloatObjectMap<V> reject(FloatObjectPredicate<? super V> predicate)
FloatObjectMapreject in interface FloatObjectMap<V>predicate - the predicate to determine which key/value pairs in this map should be
excluded from the returned mapMutableFloatObjectMap<V> withKeyValue(float key, V value)
value.key - the keyvalue - the value to associate with value#put(float, V)MutableFloatObjectMap<V> withoutKey(float key)
key - the key to removeremove(float)MutableFloatObjectMap<V> withoutAllKeys(FloatIterable keys)
keys - the keys to removeremove(float)default MutableFloatObjectMap<V> withAllKeyValues(Iterable<FloatObjectPair<V>> keyValuePairs)
iterable - the pairs to put into this mapputPair(FloatObjectPair)MutableFloatObjectMap<V> asUnmodifiable()
UnsupportedOperationException for all mutating operations.
This avoids the overhead of copying the map when calling FloatObjectMap.toImmutable() while
still providing immutability.MutableFloatObjectMap<V> asSynchronized()
Copyright © 2004–2020. All rights reserved.