ObjectDoubleHashMapWithHashingStrategy (Eclipse Collections

java.lang.Object
- org.eclipse.collections.impl.map.mutable.primitive.ObjectDoubleHashMapWithHashingStrategy<K>

All Implemented Interfaces:

Externalizable, Serializable, DoubleIterable, MutableObjectDoubleMap<K>, ObjectDoubleMap<K>, PrimitiveIterable
```
public class ObjectDoubleHashMapWithHashingStrategy<K>
extends Object
implements MutableObjectDoubleMap<K>, Externalizable
```
This file was automatically generated from template file objectPrimitiveHashMapWithHashingStrategy.stg.

Since:

7.0.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static double EMPTY_VALUE

Fields
Modifier and Type	Field and Description
`static double`	`EMPTY_VALUE`

Constructor Summary

Constructors
Constructor and Description
`ObjectDoubleHashMapWithHashingStrategy()` Deprecated. Use ObjectDoubleHashMapWithHashingStrategy(HashingStrategy) instead.
`ObjectDoubleHashMapWithHashingStrategy(HashingStrategy<? super K> hashingStrategy)`
`ObjectDoubleHashMapWithHashingStrategy(HashingStrategy<? super K> hashingStrategy, int initialCapacity)`
`ObjectDoubleHashMapWithHashingStrategy(HashingStrategy<? super K> hashingStrategy, ObjectDoubleMap<? extends K> map)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`addToValue(K key, double toBeAdded)`
`boolean`	`allSatisfy(DoublePredicate predicate)`
`boolean`	`anySatisfy(DoublePredicate predicate)`
`void`	`appendString(Appendable appendable)`
`void`	`appendString(Appendable appendable, String separator)`
`void`	`appendString(Appendable appendable, String start, String separator, String end)`
`LazyDoubleIterable`	`asLazy()`
`MutableObjectDoubleMap<K>`	`asSynchronized()`
`MutableObjectDoubleMap<K>`	`asUnmodifiable()`
`double`	`average()`
`RichIterable<DoubleIterable>`	`chunk(int size)`
`void`	`clear()`
`<V> MutableCollection<V>`	`collect(DoubleToObjectFunction<? extends V> function)`
`void`	`compact()` Rehashes every element in the set into a new backing table of the smallest possible size and eliminating removed sentinels.
`boolean`	`contains(double value)`
`boolean`	`containsAll(double... source)`
`boolean`	`containsAll(DoubleIterable source)`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(double value)`
`int`	`count(DoublePredicate predicate)`
`double`	`detectIfNone(DoublePredicate predicate, double ifNone)`
`MutableDoubleIterator`	`doubleIterator()`
`void`	`each(DoubleProcedure procedure)`
`boolean`	`equals(Object obj)`
`MutableDoubleObjectMap<K>`	`flipUniqueValues()`
`void`	`forEachKey(Procedure<? super K> procedure)`
`void`	`forEachKeyValue(ObjectDoubleProcedure<? super K> procedure)`
`void`	`forEachValue(DoubleProcedure procedure)`
`double`	`get(Object key)`
`double`	`getAndPut(K key, double putValue, double defaultValue)`
`double`	`getIfAbsent(Object key, double ifAbsent)`
`double`	`getIfAbsentPut(K key, double value)`
`double`	`getIfAbsentPut(K key, DoubleFunction0 function)`
`<P> double`	`getIfAbsentPutWith(K key, DoubleFunction<? super P> function, P parameter)`
`double`	`getIfAbsentPutWithKey(K key, DoubleFunction<? super K> function)`
`double`	`getOrThrow(Object key)`
`int`	`hashCode()`
`<V> V`	`injectInto(V injectedValue, ObjectDoubleToObjectFunction<? super V,? extends V> function)`
`boolean`	`isEmpty()`
`Set<K>`	`keySet()`
`LazyIterable<K>`	`keysView()`
`RichIterable<ObjectDoublePair<K>>`	`keyValuesView()`
`String`	`makeString()`
`String`	`makeString(String separator)`
`String`	`makeString(String start, String separator, String end)`
`double`	`max()`
`double`	`maxIfEmpty(double defaultValue)`
`double`	`median()`
`double`	`min()`
`double`	`minIfEmpty(double defaultValue)`
`static <K> ObjectDoubleHashMapWithHashingStrategy<K>`	`newMap(HashingStrategy<? super K> hashingStrategy)`
`static <K> ObjectDoubleHashMapWithHashingStrategy<K>`	`newMap(HashingStrategy<? super K> hashingStrategy, ObjectDoubleMap<K> map)`
`static <K> ObjectDoubleHashMapWithHashingStrategy<K>`	`newMap(ObjectDoubleHashMapWithHashingStrategy<K> map)`
`static <K> ObjectDoubleHashMapWithHashingStrategy<K>`	`newMapWithInitialCapacity(HashingStrategy<? super K> hashingStrategy, int initialCapacity)`
`static <K> ObjectDoubleHashMapWithHashingStrategy<K>`	`newWithKeysValues(HashingStrategy<? super K> hashingStrategy, K key1, double value1)`
`static <K> ObjectDoubleHashMapWithHashingStrategy<K>`	`newWithKeysValues(HashingStrategy<? super K> hashingStrategy, K key1, double value1, K key2, double value2)`
`static <K> ObjectDoubleHashMapWithHashingStrategy<K>`	`newWithKeysValues(HashingStrategy<? super K> hashingStrategy, K key1, double value1, K key2, double value2, K key3, double value3)`
`static <K> ObjectDoubleHashMapWithHashingStrategy<K>`	`newWithKeysValues(HashingStrategy<? super K> hashingStrategy, K key1, double value1, K key2, double value2, K key3, double value3, K key4, double value4)`
`boolean`	`noneSatisfy(DoublePredicate predicate)`
`boolean`	`notEmpty()`
`void`	`put(K key, double value)`
`void`	`putAll(ObjectDoubleMap<? extends K> map)`
`void`	`readExternal(ObjectInput in)`
`MutableDoubleCollection`	`reject(DoublePredicate predicate)`
`ObjectDoubleHashMapWithHashingStrategy<K>`	`reject(ObjectDoublePredicate<? super K> predicate)`
`void`	`remove(Object key)`
`void`	`removeKey(K key)`
`void`	`removeKeyAtIndex(K key, int index)`
`double`	`removeKeyIfAbsent(K key, double value)`
`MutableDoubleCollection`	`select(DoublePredicate predicate)`
`ObjectDoubleHashMapWithHashingStrategy<K>`	`select(ObjectDoublePredicate<? super K> predicate)`
`int`	`size()`
`double`	`sum()`
`double[]`	`toArray()`
`double[]`	`toArray(double[] target)`
`MutableDoubleBag`	`toBag()`
`ImmutableObjectDoubleMap<K>`	`toImmutable()`
`MutableDoubleList`	`toList()`
`MutableDoubleSet`	`toSet()`
`double[]`	`toSortedArray()`
`MutableDoubleList`	`toSortedList()`
`String`	`toString()`
`double`	`updateValue(K key, double initialValueIfAbsent, DoubleToDoubleFunction function)`
`void`	`updateValues(ObjectDoubleToDoubleFunction<? super K> function)`
`MutableDoubleCollection`	`values()`
`ObjectDoubleHashMapWithHashingStrategy<K>`	`withKeysValues(K key1, double value1, K key2, double value2)`
`ObjectDoubleHashMapWithHashingStrategy<K>`	`withKeysValues(K key1, double value1, K key2, double value2, K key3, double value3)`
`ObjectDoubleHashMapWithHashingStrategy<K>`	`withKeysValues(K key1, double value1, K key2, double value2, K key3, double value3, K key4, double value4)`
`ObjectDoubleHashMapWithHashingStrategy<K>`	`withKeyValue(K key1, double value1)`
`ObjectDoubleHashMapWithHashingStrategy<K>`	`withoutAllKeys(Iterable<? extends K> keys)`
`ObjectDoubleHashMapWithHashingStrategy<K>`	`withoutKey(K key)`
`void`	`writeExternal(ObjectOutput out)`

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.collections.api.map.primitive.MutableObjectDoubleMap
putPair, tap, withAllKeyValues

Methods inherited from interface org.eclipse.collections.api.map.primitive.ObjectDoubleMap
injectIntoKeyValue

Methods inherited from interface org.eclipse.collections.api.DoubleIterable
averageIfEmpty, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, containsAny, containsAny, containsNone, containsNone, flatCollect, forEach, injectIntoBoolean, injectIntoByte, injectIntoChar, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, injectIntoShort, medianIfEmpty, reduce, reduceIfEmpty, reject, select, summaryStatistics, toSortedList, toSortedListBy, toSortedListBy

Field Detail
- EMPTY_VALUE
```
public static final double EMPTY_VALUE
```
  See Also:
  
  Constant Field Values

Constructor Detail

ObjectDoubleHashMapWithHashingStrategy
```
@Deprecated
public ObjectDoubleHashMapWithHashingStrategy()
```
Deprecated. Use ObjectDoubleHashMapWithHashingStrategy(HashingStrategy) instead.

ObjectDoubleHashMapWithHashingStrategy

public ObjectDoubleHashMapWithHashingStrategy(HashingStrategy<? super K> hashingStrategy)

ObjectDoubleHashMapWithHashingStrategy

public ObjectDoubleHashMapWithHashingStrategy(HashingStrategy<? super K> hashingStrategy,
                                              int initialCapacity)

ObjectDoubleHashMapWithHashingStrategy

public ObjectDoubleHashMapWithHashingStrategy(HashingStrategy<? super K> hashingStrategy,
                                              ObjectDoubleMap<? extends K> map)

Method Detail

newMap

public static <K> ObjectDoubleHashMapWithHashingStrategy<K> newMap(HashingStrategy<? super K> hashingStrategy)

newMap

public static <K> ObjectDoubleHashMapWithHashingStrategy<K> newMap(HashingStrategy<? super K> hashingStrategy,
                                                                   ObjectDoubleMap<K> map)

newMap

public static <K> ObjectDoubleHashMapWithHashingStrategy<K> newMap(ObjectDoubleHashMapWithHashingStrategy<K> map)

newMapWithInitialCapacity

public static <K> ObjectDoubleHashMapWithHashingStrategy<K> newMapWithInitialCapacity(HashingStrategy<? super K> hashingStrategy,
                                                                                      int initialCapacity)

newWithKeysValues

public static <K> ObjectDoubleHashMapWithHashingStrategy<K> newWithKeysValues(HashingStrategy<? super K> hashingStrategy,
                                                                              K key1,
                                                                              double value1)

newWithKeysValues

public static <K> ObjectDoubleHashMapWithHashingStrategy<K> newWithKeysValues(HashingStrategy<? super K> hashingStrategy,
                                                                              K key1,
                                                                              double value1,
                                                                              K key2,
                                                                              double value2)

newWithKeysValues

public static <K> ObjectDoubleHashMapWithHashingStrategy<K> newWithKeysValues(HashingStrategy<? super K> hashingStrategy,
                                                                              K key1,
                                                                              double value1,
                                                                              K key2,
                                                                              double value2,
                                                                              K key3,
                                                                              double value3)

newWithKeysValues

public static <K> ObjectDoubleHashMapWithHashingStrategy<K> newWithKeysValues(HashingStrategy<? super K> hashingStrategy,
                                                                              K key1,
                                                                              double value1,
                                                                              K key2,
                                                                              double value2,
                                                                              K key3,
                                                                              double value3,
                                                                              K key4,
                                                                              double value4)

equals
```
public boolean equals(Object obj)
```
Overrides:

equals in class Object

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

toString
```
public String toString()
```
Specified by:

toString in interface ObjectDoubleMap<K>

Specified by:

toString in interface PrimitiveIterable

Overrides:

toString in class Object

size
```
public int size()
```
Specified by:

size in interface PrimitiveIterable

isEmpty
```
public boolean isEmpty()
```
Specified by:

isEmpty in interface PrimitiveIterable

notEmpty
```
public boolean notEmpty()
```
Specified by:

notEmpty in interface PrimitiveIterable

makeString
```
public String makeString()
```
Specified by:

makeString in interface PrimitiveIterable

makeString
```
public String makeString(String separator)
```
Specified by:

makeString in interface PrimitiveIterable

makeString

public String makeString(String start,
                         String separator,
                         String end)

Specified by:: makeString in interface PrimitiveIterable

appendString
```
public void appendString(Appendable appendable)
```
Specified by:

appendString in interface PrimitiveIterable

appendString

public void appendString(Appendable appendable,
                         String separator)

Specified by:: appendString in interface PrimitiveIterable

appendString

public void appendString(Appendable appendable,
                         String start,
                         String separator,
                         String end)

Specified by:: appendString in interface PrimitiveIterable

doubleIterator
```
public MutableDoubleIterator doubleIterator()
```
Specified by:

doubleIterator in interface DoubleIterable

Specified by:

doubleIterator in interface MutableObjectDoubleMap<K>

toArray
```
public double[] toArray()
```
Specified by:

toArray in interface DoubleIterable

toArray
```
public double[] toArray(double[] target)
```
Specified by:

toArray in interface DoubleIterable

contains
```
public boolean contains(double value)
```
Specified by:

contains in interface DoubleIterable

containsAll
```
public boolean containsAll(double... source)
```
Specified by:

containsAll in interface DoubleIterable

containsAll
```
public boolean containsAll(DoubleIterable source)
```
Specified by:

containsAll in interface DoubleIterable

clear
```
public void clear()
```
Specified by:

clear in interface MutableObjectDoubleMap<K>

put

public void put(K key,
                double value)

Specified by:: put in interface MutableObjectDoubleMap<K>

putAll
```
public void putAll(ObjectDoubleMap<? extends K> map)
```
Specified by:

putAll in interface MutableObjectDoubleMap<K>

updateValues

public void updateValues(ObjectDoubleToDoubleFunction<? super K> function)

Specified by:: updateValues in interface MutableObjectDoubleMap<K>

removeKey
```
public void removeKey(K key)
```
Specified by:

removeKey in interface MutableObjectDoubleMap<K>

removeKeyAtIndex

public void removeKeyAtIndex(K key,
                             int index)

remove
```
public void remove(Object key)
```
Specified by:

remove in interface MutableObjectDoubleMap<K>

removeKeyIfAbsent

public double removeKeyIfAbsent(K key,
                                double value)

Specified by:: removeKeyIfAbsent in interface MutableObjectDoubleMap<K>

getIfAbsentPut

public double getIfAbsentPut(K key,
                             double value)

Specified by:: getIfAbsentPut in interface MutableObjectDoubleMap<K>

getAndPut

public double getAndPut(K key,
                        double putValue,
                        double defaultValue)

Specified by:: getAndPut in interface MutableObjectDoubleMap<K>

getIfAbsentPut

public double getIfAbsentPut(K key,
                             DoubleFunction0 function)

Specified by:: getIfAbsentPut in interface MutableObjectDoubleMap<K>

getIfAbsentPutWith

public <P> double getIfAbsentPutWith(K key,
                                     DoubleFunction<? super P> function,
                                     P parameter)

Specified by:: getIfAbsentPutWith in interface MutableObjectDoubleMap<K>

getIfAbsentPutWithKey

public double getIfAbsentPutWithKey(K key,
                                    DoubleFunction<? super K> function)

Specified by:: getIfAbsentPutWithKey in interface MutableObjectDoubleMap<K>

updateValue

public double updateValue(K key,
                          double initialValueIfAbsent,
                          DoubleToDoubleFunction function)

Specified by:: updateValue in interface MutableObjectDoubleMap<K>

addToValue

public double addToValue(K key,
                         double toBeAdded)

Specified by:: addToValue in interface MutableObjectDoubleMap<K>

withKeyValue

public ObjectDoubleHashMapWithHashingStrategy<K> withKeyValue(K key1,
                                                              double value1)

Specified by:: withKeyValue in interface MutableObjectDoubleMap<K>

withKeysValues

public ObjectDoubleHashMapWithHashingStrategy<K> withKeysValues(K key1,
                                                                double value1,
                                                                K key2,
                                                                double value2)

withKeysValues

public ObjectDoubleHashMapWithHashingStrategy<K> withKeysValues(K key1,
                                                                double value1,
                                                                K key2,
                                                                double value2,
                                                                K key3,
                                                                double value3)

withKeysValues

public ObjectDoubleHashMapWithHashingStrategy<K> withKeysValues(K key1,
                                                                double value1,
                                                                K key2,
                                                                double value2,
                                                                K key3,
                                                                double value3,
                                                                K key4,
                                                                double value4)

withoutKey

public ObjectDoubleHashMapWithHashingStrategy<K> withoutKey(K key)

Specified by:: withoutKey in interface MutableObjectDoubleMap<K>

withoutAllKeys

public ObjectDoubleHashMapWithHashingStrategy<K> withoutAllKeys(Iterable<? extends K> keys)

Specified by:: withoutAllKeys in interface MutableObjectDoubleMap<K>

asUnmodifiable
```
public MutableObjectDoubleMap<K> asUnmodifiable()
```
Specified by:

asUnmodifiable in interface MutableObjectDoubleMap<K>

asSynchronized
```
public MutableObjectDoubleMap<K> asSynchronized()
```
Specified by:

asSynchronized in interface MutableObjectDoubleMap<K>

toImmutable
```
public ImmutableObjectDoubleMap<K> toImmutable()
```
Specified by:

toImmutable in interface ObjectDoubleMap<K>

get
```
public double get(Object key)
```
Specified by:

get in interface ObjectDoubleMap<K>

getOrThrow
```
public double getOrThrow(Object key)
```
Specified by:

getOrThrow in interface ObjectDoubleMap<K>

getIfAbsent

public double getIfAbsent(Object key,
                          double ifAbsent)

Specified by:: getIfAbsent in interface ObjectDoubleMap<K>

containsKey
```
public boolean containsKey(Object key)
```
Specified by:

containsKey in interface ObjectDoubleMap<K>

containsValue
```
public boolean containsValue(double value)
```
Specified by:

containsValue in interface ObjectDoubleMap<K>

each

public void each(DoubleProcedure procedure)

Specified by:: each in interface DoubleIterable

forEachValue
```
public void forEachValue(DoubleProcedure procedure)
```
Specified by:

forEachValue in interface ObjectDoubleMap<K>

forEachKey
```
public void forEachKey(Procedure<? super K> procedure)
```
Specified by:

forEachKey in interface ObjectDoubleMap<K>

forEachKeyValue

public void forEachKeyValue(ObjectDoubleProcedure<? super K> procedure)

Specified by:: forEachKeyValue in interface ObjectDoubleMap<K>

select
```
public ObjectDoubleHashMapWithHashingStrategy<K> select(ObjectDoublePredicate<? super K> predicate)
```
Specified by:

select in interface MutableObjectDoubleMap<K>

Specified by:

select in interface ObjectDoubleMap<K>

reject
```
public ObjectDoubleHashMapWithHashingStrategy<K> reject(ObjectDoublePredicate<? super K> predicate)
```
Specified by:

reject in interface MutableObjectDoubleMap<K>

Specified by:

reject in interface ObjectDoubleMap<K>

select
```
public MutableDoubleCollection select(DoublePredicate predicate)
```
Specified by:

select in interface DoubleIterable

Specified by:

select in interface MutableObjectDoubleMap<K>

reject
```
public MutableDoubleCollection reject(DoublePredicate predicate)
```
Specified by:

reject in interface DoubleIterable

Specified by:

reject in interface MutableObjectDoubleMap<K>

detectIfNone

public double detectIfNone(DoublePredicate predicate,
                           double ifNone)

Specified by:: detectIfNone in interface DoubleIterable

collect
```
public <V> MutableCollection<V> collect(DoubleToObjectFunction<? extends V> function)
```
Specified by:

collect in interface DoubleIterable

Specified by:

collect in interface MutableObjectDoubleMap<K>

count
```
public int count(DoublePredicate predicate)
```
Specified by:

count in interface DoubleIterable

anySatisfy
```
public boolean anySatisfy(DoublePredicate predicate)
```
Specified by:

anySatisfy in interface DoubleIterable

allSatisfy
```
public boolean allSatisfy(DoublePredicate predicate)
```
Specified by:

allSatisfy in interface DoubleIterable

noneSatisfy
```
public boolean noneSatisfy(DoublePredicate predicate)
```
Specified by:

noneSatisfy in interface DoubleIterable

injectInto

public <V> V injectInto(V injectedValue,
                        ObjectDoubleToObjectFunction<? super V,? extends V> function)

Specified by:: injectInto in interface DoubleIterable

chunk

public RichIterable<DoubleIterable> chunk(int size)

Specified by:: chunk in interface DoubleIterable

sum
```
public double sum()
```
Specified by:

sum in interface DoubleIterable

max
```
public double max()
```
Specified by:

max in interface DoubleIterable

min
```
public double min()
```
Specified by:

min in interface DoubleIterable

maxIfEmpty
```
public double maxIfEmpty(double defaultValue)
```
Specified by:

maxIfEmpty in interface DoubleIterable

minIfEmpty
```
public double minIfEmpty(double defaultValue)
```
Specified by:

minIfEmpty in interface DoubleIterable

average
```
public double average()
```
Specified by:

average in interface DoubleIterable

median
```
public double median()
```
Specified by:

median in interface DoubleIterable

toList
```
public MutableDoubleList toList()
```
Specified by:

toList in interface DoubleIterable

toSet
```
public MutableDoubleSet toSet()
```
Specified by:

toSet in interface DoubleIterable

toBag
```
public MutableDoubleBag toBag()
```
Specified by:

toBag in interface DoubleIterable

asLazy
```
public LazyDoubleIterable asLazy()
```
Specified by:

asLazy in interface DoubleIterable

toSortedArray
```
public double[] toSortedArray()
```
Specified by:

toSortedArray in interface DoubleIterable

toSortedList
```
public MutableDoubleList toSortedList()
```
Specified by:

toSortedList in interface DoubleIterable

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Specified by:: writeExternal in interface Externalizable
Throws:: IOException

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Specified by:: readExternal in interface Externalizable
Throws:: IOException; ClassNotFoundException

keysView
```
public LazyIterable<K> keysView()
```
Specified by:

keysView in interface ObjectDoubleMap<K>

keyValuesView
```
public RichIterable<ObjectDoublePair<K>> keyValuesView()
```
Specified by:

keyValuesView in interface ObjectDoubleMap<K>

flipUniqueValues
```
public MutableDoubleObjectMap<K> flipUniqueValues()
```
Specified by:

flipUniqueValues in interface MutableObjectDoubleMap<K>

Specified by:

flipUniqueValues in interface ObjectDoubleMap<K>

compact
```
public void compact()
```
Rehashes every element in the set into a new backing table of the smallest possible size and eliminating removed sentinels.

keySet
```
public Set<K> keySet()
```
Specified by:

keySet in interface ObjectDoubleMap<K>

values
```
public MutableDoubleCollection values()
```
Specified by:

values in interface ObjectDoubleMap<K>

Class ObjectDoubleHashMapWithHashingStrategy<K>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.collections.api.map.primitive.MutableObjectDoubleMap

Methods inherited from interface org.eclipse.collections.api.map.primitive.ObjectDoubleMap

Methods inherited from interface org.eclipse.collections.api.DoubleIterable

Field Detail

EMPTY_VALUE

Constructor Detail

ObjectDoubleHashMapWithHashingStrategy

ObjectDoubleHashMapWithHashingStrategy

ObjectDoubleHashMapWithHashingStrategy

ObjectDoubleHashMapWithHashingStrategy

Method Detail

newMap

newMap

newMap

newMapWithInitialCapacity

newWithKeysValues

newWithKeysValues

newWithKeysValues

newWithKeysValues

equals

hashCode

toString

size

isEmpty

notEmpty

makeString

makeString

makeString

appendString

appendString

appendString

doubleIterator

toArray

toArray

contains

containsAll

containsAll

clear

put

putAll

updateValues

removeKey

removeKeyAtIndex

remove

removeKeyIfAbsent

getIfAbsentPut

getAndPut

getIfAbsentPut

getIfAbsentPutWith

getIfAbsentPutWithKey

updateValue

addToValue

withKeyValue

withKeysValues

withKeysValues

withKeysValues

withoutKey

withoutAllKeys

asUnmodifiable

asSynchronized

toImmutable

get

getOrThrow

getIfAbsent

containsKey

containsValue

each

forEachValue

forEachKey

forEachKeyValue

select

reject

select

reject

detectIfNone