Uses of Interface
org.eclipse.collections.api.map.MutableMap

Packages that use MutableMap

Package	Description
org.eclipse.collections.api	This package contains interfaces for Eclipse Collections API.
org.eclipse.collections.api.bag	This package contains interfaces for Bag API.
org.eclipse.collections.api.collection	This package contains FixedSizeCollection, ImmutableCollection and MutableCollection API.
org.eclipse.collections.api.factory.map	This package contains factory API for creating instances of type MapIterable.
org.eclipse.collections.api.factory.map.strategy	This package contains factory API for creating instances of maps with user defined HashingStrategys.
org.eclipse.collections.api.map	This package contains interfaces for map API which enhance the performance and functionality of Map
org.eclipse.collections.api.map.primitive	This package contains API for primitive to primitive maps, primitive to object maps and object to primitive maps with mutable and immutable variants.
org.eclipse.collections.api.map.sorted	This package contains mutable and immutable sorted map interfaces.
org.eclipse.collections.api.multimap	This package contains interfaces for Multimap.
org.eclipse.collections.api.stack	This package contains interfaces for stack API.
org.eclipse.collections.impl	This package contains implementations for Eclipse Collections API.
org.eclipse.collections.impl.bag.immutable	This package contains implementations of the ImmutableBag interface.
org.eclipse.collections.impl.bag.mutable	This package contains implementations of the MutableBag interface.
org.eclipse.collections.impl.bimap
org.eclipse.collections.impl.bimap.immutable
org.eclipse.collections.impl.bimap.mutable	This package contains implementations of the MutableBiMap interface.
org.eclipse.collections.impl.block.factory	This package contains factory implementations for Function, Predicate, SerializableComparator and Procedure.
org.eclipse.collections.impl.collection
org.eclipse.collections.impl.collection.mutable	This package contains implementations of the MutableCollection interface.
org.eclipse.collections.impl.collector
org.eclipse.collections.impl.factory	This package contains static utilities for creating mutable and immutable collection factories.
org.eclipse.collections.impl.forkjoin	This package contains implementations which has several parallel algorithms that work with Collections and make use of Java's fork-join framework.
org.eclipse.collections.impl.lazy.parallel
org.eclipse.collections.impl.list.mutable	This package contains implementations of the MutableList interface.
org.eclipse.collections.impl.map	This package contains implementations of the MapIterable interface.
org.eclipse.collections.impl.map.immutable	This package contains implementations of the ImmutableMap interface.
org.eclipse.collections.impl.map.mutable	This package contains implementations of the MutableMap interface.
org.eclipse.collections.impl.map.mutable.primitive	This package contains implementations of the mutable primitive-primitive, primitive-object and object-primitive map interfaces.
org.eclipse.collections.impl.map.ordered.mutable
org.eclipse.collections.impl.map.sorted.mutable	This package contains implementations of the MutableSortedMap interface.
org.eclipse.collections.impl.map.strategy.mutable	This package contains mutable map implementations backed by hashtables that rely on HashingStrategys provided by the developer to compute the hashCode and equals for the objects stored in the map.
org.eclipse.collections.impl.multimap	This package contains implementations of the Multimap interface.
org.eclipse.collections.impl.multimap.bag	This package contains implementations of the BagMultimap interface.
org.eclipse.collections.impl.multimap.bag.sorted.immutable
org.eclipse.collections.impl.multimap.list	This package contains implementations of the ListMultimap interface.
org.eclipse.collections.impl.multimap.set	This package contains implementations of the SetMultimap interface.
org.eclipse.collections.impl.multimap.set.sorted	This package contains implementations of the SortedSetMultimap interface.
org.eclipse.collections.impl.parallel	This package contains classes which is used for parallel iteration through the containers.
org.eclipse.collections.impl.set
org.eclipse.collections.impl.set.mutable	This package package contains implementations of MutableSet.
org.eclipse.collections.impl.stack.mutable	This package contains implementations of the MutableStack interface.
org.eclipse.collections.impl.utility	This package contains static utilities that provide iteration pattern implementations which work with JCF collections.
org.eclipse.collections.impl.utility.internal	This package contains static utilities that provide internal iteration pattern implementations which work with JCF collections.

Uses of MutableMap in org.eclipse.collections.api

Methods in org.eclipse.collections.api that return MutableMap

Modifier and Type	Method	Description
<NK, NV> MutableMap<NK,NV>	ParallelIterable.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	RichIterable.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)	Converts the collection to a MutableMap implementation using the specified key and value functions.

Uses of MutableMap in org.eclipse.collections.api.bag

Methods in org.eclipse.collections.api.bag that return MutableMap

Modifier and Type	Method	Description
MutableMap<T,Integer>	MutableBag.toMapOfItemToCount()

Uses of MutableMap in org.eclipse.collections.api.collection

Methods in org.eclipse.collections.api.collection that return MutableMap

Modifier and Type	Method	Description
default <K, V> MutableMap<K,V>	MutableCollection.aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
default <K, V> MutableMap<K,V>	MutableCollection.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
default <V> MutableMap<V,T>	MutableCollection.groupByUniqueKey(Function<? super T,? extends V> function)

Uses of MutableMap in org.eclipse.collections.api.factory.map

Methods in org.eclipse.collections.api.factory.map that return MutableMap

Modifier and Type	Method	Description
<K, V> MutableMap<K,V>	MutableMapFactory.empty()
<K, V> MutableMap<K,V>	MutableMapFactory.of()	Same as MutableMapFactory.empty().
<K, V> MutableMap<K,V>	MutableMapFactory.of(K key, V value)	Same as MutableMapFactory.with(Object, Object).
<K, V> MutableMap<K,V>	MutableMapFactory.of(K key1, V value1, K key2, V value2)	Same as MutableMapFactory.with(Object, Object, Object, Object).
<K, V> MutableMap<K,V>	MutableMapFactory.of(K key1, V value1, K key2, V value2, K key3, V value3)	Same as MutableMapFactory.with(Object, Object, Object, Object, Object, Object).
<K, V> MutableMap<K,V>	MutableMapFactory.of(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)	Same as MutableMapFactory.with(Object, Object, Object, Object, Object, Object, Object, Object).
<K, V> MutableMap<K,V>	MutableMapFactory.ofInitialCapacity(int capacity)	Same as MutableMapFactory.empty().
<K, V> MutableMap<K,V>	MutableMapFactory.ofMap(Map<? extends K,? extends V> map)
<K, V> MutableMap<K,V>	MutableMapFactory.ofMapIterable(MapIterable<? extends K,? extends V> mapIterable)
<K, V> MutableMap<K,V>	MutableMapFactory.with()	Same as MutableMapFactory.empty().
<K, V> MutableMap<K,V>	MutableMapFactory.with(K key, V value)
<K, V> MutableMap<K,V>	MutableMapFactory.with(K key1, V value1, K key2, V value2)
<K, V> MutableMap<K,V>	MutableMapFactory.with(K key1, V value1, K key2, V value2, K key3, V value3)
<K, V> MutableMap<K,V>	MutableMapFactory.with(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
<K, V> MutableMap<K,V>	MutableMapFactory.withInitialCapacity(int capacity)	Same as MutableMapFactory.empty().
<K, V> MutableMap<K,V>	MutableMapFactory.withMap(Map<? extends K,? extends V> map)
<K, V> MutableMap<K,V>	MutableMapFactory.withMapIterable(MapIterable<? extends K,? extends V> mapIterable)

Uses of MutableMap in org.eclipse.collections.api.factory.map.strategy

Methods in org.eclipse.collections.api.factory.map.strategy that return MutableMap

Modifier and Type	Method	Description
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.of(HashingStrategy<? super K> hashingStrategy)	Same as MutableHashingStrategyMapFactory.with(HashingStrategy).
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.of(HashingStrategy<? super K> hashingStrategy, K key, V value)	Same as MutableHashingStrategyMapFactory.with(HashingStrategy, Object, Object).
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.of(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2)	Same as MutableHashingStrategyMapFactory.with(HashingStrategy, Object, Object, Object, Object).
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.of(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2, K key3, V value3)	Same as MutableHashingStrategyMapFactory.with(HashingStrategy, Object, Object, Object, Object, Object, Object).
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.of(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)	Same as MutableHashingStrategyMapFactory.with(HashingStrategy, Object, Object, Object, Object, Object, Object, Object, Object).
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.with(HashingStrategy<? super K> hashingStrategy)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.with(HashingStrategy<? super K> hashingStrategy, K key, V value)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.with(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.with(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2, K key3, V value3)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactory.with(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)

Uses of MutableMap in org.eclipse.collections.api.map

Subinterfaces of MutableMap in org.eclipse.collections.api.map

Modifier and Type	Interface	Description
interface	ConcurrentMutableMap<K,V>	A ConcurrentMutableMap provides an api which combines and supports both MutableMap and ConcurrentMap.
interface	FixedSizeMap<K,V>	A FixedSizeMap is a map that may be mutated, but cannot grow or shrink in size.

Methods in org.eclipse.collections.api.map that return MutableMap

Modifier and Type	Method	Description
default <K1, V1, V2> MutableMap<K1,V2>	MutableMap.aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
default <KK, VV> MutableMap<KK,VV>	MutableMap.aggregateBy(Function<? super V,? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
default <K1, V1, V2> MutableMap<K1,V2>	MutableMapIterable.aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
default <KK, VV> MutableMap<KK,VV>	MutableMapIterable.aggregateBy(Function<? super V,? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
default <KK, VV> MutableMap<KK,VV>	MutableMap.aggregateInPlaceBy(Function<? super V,? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
default <KK, VV> MutableMap<KK,VV>	MutableMapIterable.aggregateInPlaceBy(Function<? super V,? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
MutableMap<K,V>	MutableMap.asSynchronized()
MutableMap<K,V>	MutableMap.asUnmodifiable()
MutableMap<K,V>	MutableMap.clone()
<K2, V2> MutableMap<K2,V2>	MutableMap.collect(Function2<? super K,? super V,Pair<K2,V2>> function)
<E> MutableMap<K,V>	MutableMap.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)	Adds all the entries derived from iterable to this.
<R> MutableMap<K,R>	MutableMap.collectValues(Function2<? super K,? super V,? extends R> function)
MutableMap<V,K>	MutableMap.flipUniqueValues()
default <V1> MutableMap<V1,V>	MutableMap.groupByUniqueKey(Function<? super V,? extends V1> function)
MutableMap<K,V>	MutableMap.newEmpty()
MutableMap<K,V>	MutableMap.reject(Predicate2<? super K,? super V> predicate)
MutableMap<K,V>	MutableMap.select(Predicate2<? super K,? super V> predicate)
MutableMap<K,V>	MutableMap.tap(Procedure<? super V> procedure)
MutableMap<K,V>	ImmutableMap.toMap()
MutableMap<K,V>	MutableMap.withAllKeyValueArguments(Pair<? extends K,? extends V>... keyValuePairs)
MutableMap<K,V>	MutableMap.withAllKeyValues(Iterable<? extends Pair<? extends K,? extends V>> keyValues)
MutableMap<K,V>	MutableMap.withKeyValue(K key, V value)
default MutableMap<K,V>	MutableMap.withMap(Map<? extends K,? extends V> map)
MutableMap<K,V>	MutableMap.withoutAllKeys(Iterable<? extends K> keys)
MutableMap<K,V>	MutableMap.withoutKey(K key)

Uses of MutableMap in org.eclipse.collections.api.map.primitive

Methods in org.eclipse.collections.api.map.primitive that return MutableMap

Modifier and Type	Method	Description
default <K, VV> MutableMap<K,VV>	MutablePrimitiveObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	MutablePrimitiveObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
default <VV> MutableMap<VV,V>	MutablePrimitiveObjectMap.groupByUniqueKey(Function<? super V,? extends VV> function)

Uses of MutableMap in org.eclipse.collections.api.map.sorted

Methods in org.eclipse.collections.api.map.sorted that return MutableMap

Modifier and Type	Method	Description
<K2, V2> MutableMap<K2,V2>	MutableSortedMap.collect(Function2<? super K,? super V,Pair<K2,V2>> function)
default <VV> MutableMap<VV,V>	MutableSortedMap.groupByUniqueKey(Function<? super V,? extends VV> function)

Uses of MutableMap in org.eclipse.collections.api.multimap

Methods in org.eclipse.collections.api.multimap that return MutableMap

Modifier and Type	Method	Description
MutableMap<K,RichIterable<V>>	Multimap.toMap()	Returns a new MutableMap of keys from this Multimap to the mapped values as a RichIterable.
<R extends Collection<V>> MutableMap<K,R>	Multimap.toMap(Function0<R> collectionFactory)	Returns a new MutableMap of keys from this Multimap to the mapped values as a RichIterable.

Uses of MutableMap in org.eclipse.collections.api.stack

Methods in org.eclipse.collections.api.stack that return MutableMap

Modifier and Type	Method	Description
default <K, V> MutableMap<K,V>	MutableStack.aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
default <K, V> MutableMap<K,V>	MutableStack.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
default <V> MutableMap<V,T>	MutableStack.groupByUniqueKey(Function<? super T,? extends V> function)

Uses of MutableMap in org.eclipse.collections.impl

Methods in org.eclipse.collections.impl that return MutableMap

Modifier and Type	Method	Description
<K, V> MutableMap<K,V>	AbstractRichIterable.toMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableRichIterable.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.bag.immutable

Methods in org.eclipse.collections.impl.bag.immutable that return MutableMap

Modifier and Type	Method	Description
<K, V> MutableMap<K,V>	ImmutableHashBag.toMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)
MutableMap<T,Integer>	ImmutableArrayBag.toMapOfItemToCount()
MutableMap<T,Integer>	ImmutableHashBag.toMapOfItemToCount()

Uses of MutableMap in org.eclipse.collections.impl.bag.mutable

Methods in org.eclipse.collections.impl.bag.mutable that return MutableMap

Modifier and Type	Method	Description
<K, V> MutableMap<K,V>	AbstractMutableBagIterable.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<V> MutableMap<V,T>	AbstractMutableBagIterable.groupByUniqueKey(Function<? super T,? extends V> function)
<V> MutableMap<V,T>	MultiReaderHashBag.groupByUniqueKey(Function<? super T,? extends V> function)
MutableMap<T,Integer>	AbstractHashBag.toMapOfItemToCount()
MutableMap<T,Integer>	MultiReaderHashBag.toMapOfItemToCount()
MutableMap<T,Integer>	SynchronizedBag.toMapOfItemToCount()
MutableMap<T,Integer>	UnmodifiableBag.toMapOfItemToCount()

Uses of MutableMap in org.eclipse.collections.impl.bimap

Methods in org.eclipse.collections.impl.bimap that return MutableMap

Modifier and Type	Method	Description
<NK, NV> MutableMap<NK,NV>	AbstractBiMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.bimap.immutable

Methods in org.eclipse.collections.impl.bimap.immutable that return MutableMap

Modifier and Type	Method	Description
MutableMap<K,V>	AbstractImmutableBiMap.toMap()

Uses of MutableMap in org.eclipse.collections.impl.bimap.mutable

Methods in org.eclipse.collections.impl.bimap.mutable that return MutableMap

Modifier and Type	Method	Description
<K1, V1, V2> MutableMap<K1,V2>	UnmodifiableBiMap.aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
<K, V1> MutableMap<K,V1>	UnmodifiableBiMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends V1> zeroValueFactory, Function2<? super V1,? super V,? extends V1> nonMutatingAggregator)
<K, V1> MutableMap<K,V1>	UnmodifiableBiMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends V1> zeroValueFactory, Procedure2<? super V1,? super V> mutatingAggregator)
<NK, NV> MutableMap<NK,NV>	UnmodifiableBiMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.block.factory

Methods in org.eclipse.collections.impl.block.factory that return types with arguments of type MutableMap

Modifier and Type	Method	Description
static <K, V> Function0<MutableMap<K,V>>	Functions0.newUnifiedMap()

Uses of MutableMap in org.eclipse.collections.impl.collection

Methods in org.eclipse.collections.impl.collection that return MutableMap

Modifier and Type	Method	Description
<NK, NV> MutableMap<NK,NV>	AbstractSynchronizedRichIterable.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.collection.mutable

Methods in org.eclipse.collections.impl.collection.mutable that return MutableMap

Modifier and Type	Method	Description
<K, V> MutableMap<K,V>	AbstractSynchronizedMutableCollection.aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
<K, V> MutableMap<K,V>	AbstractCollectionAdapter.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<K, V> MutableMap<K,V>	AbstractMultiReaderMutableCollection.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<K, V> MutableMap<K,V>	AbstractMutableCollection.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<K, V> MutableMap<K,V>	AbstractSynchronizedMutableCollection.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<K, V> MutableMap<K,V>	AbstractUnmodifiableMutableCollection.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<V> MutableMap<V,T>	AbstractCollectionAdapter.groupByUniqueKey(Function<? super T,? extends V> function)
<V> MutableMap<V,T>	AbstractMutableCollection.groupByUniqueKey(Function<? super T,? extends V> function)
<V> MutableMap<V,T>	AbstractSynchronizedMutableCollection.groupByUniqueKey(Function<? super T,? extends V> function)
<V> MutableMap<V,T>	AbstractUnmodifiableMutableCollection.groupByUniqueKey(Function<? super T,? extends V> function)
<K, V> MutableMap<K,V>	AbstractCollectionAdapter.toMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)
<NK, NV> MutableMap<NK,NV>	AbstractMultiReaderMutableCollection.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	AbstractUnmodifiableMutableCollection.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.collector

Methods in org.eclipse.collections.impl.collector that return types with arguments of type MutableMap

Modifier and Type	Method	Description
static <T, V> Collector<T,?,MutableMap<V,BigDecimal>>	Collectors2.sumByBigDecimal(Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)	Groups and sums the values using the two specified functions.
static <T, V> Collector<T,?,MutableMap<V,BigInteger>>	Collectors2.sumByBigInteger(Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)	Groups and sums the values using the two specified functions.
static <T, K, V> Collector<T,?,MutableMap<K,V>>	Collectors2.toMap(Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)	Returns the elements as a MutableMap applying the keyFunction and valueFunction to each element.

Uses of MutableMap in org.eclipse.collections.impl.factory

Methods in org.eclipse.collections.impl.factory that return MutableMap

Modifier and Type	Method	Description
static <K, V> MutableMap<K,V>	Maps.adapt(Map<K,V> map)
static <K, V> MutableMap<K,V>	Iterables.mMap()
static <K, V> MutableMap<K,V>	Iterables.mMap(K key, V value)
static <K, V> MutableMap<K,V>	Iterables.mMap(K key1, V value1, K key2, V value2)
static <K, V> MutableMap<K,V>	Iterables.mMap(K key1, V value1, K key2, V value2, K key3, V value3)
static <K, V> MutableMap<K,V>	Iterables.mMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)

Uses of MutableMap in org.eclipse.collections.impl.forkjoin

Methods in org.eclipse.collections.impl.forkjoin that return MutableMap

Modifier and Type	Method	Description
static <T, K, V> MutableMap<K,V>	FJIterate.aggregateBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
static <T, K, V> MutableMap<K,V>	FJIterate.aggregateBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator, int batchSize)
static <T, K, V> MutableMap<K,V>	FJIterate.aggregateBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator, int batchSize, ForkJoinPool executor)
static <T, K, V> MutableMap<K,V>	FJIterate.aggregateInPlaceBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
static <T, K, V> MutableMap<K,V>	FJIterate.aggregateInPlaceBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator, int batchSize)
static <T, K, V> MutableMap<K,V>	FJIterate.aggregateInPlaceBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator, int batchSize, ForkJoinPool executor)

Uses of MutableMap in org.eclipse.collections.impl.lazy.parallel

Methods in org.eclipse.collections.impl.lazy.parallel that return MutableMap

Modifier and Type	Method	Description
<NK, NV> MutableMap<NK,NV>	AbstractMultiReaderParallelIterable.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	AbstractParallelIterable.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	AbstractSynchronizedParallelIterable.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	NonParallelIterable.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.list.mutable

Methods in org.eclipse.collections.impl.list.mutable that return MutableMap

Modifier and Type	Method	Description
<K> MutableMap<K,T>	AbstractMutableList.groupByUniqueKey(Function<? super T,? extends K> function)
<K> MutableMap<K,T>	FastList.groupByUniqueKey(Function<? super T,? extends K> function)
<V> MutableMap<V,T>	MultiReaderFastList.groupByUniqueKey(Function<? super T,? extends V> function)

Uses of MutableMap in org.eclipse.collections.impl.map

Methods in org.eclipse.collections.impl.map that return MutableMap

Modifier and Type	Method	Description
<K1, V1, V2> MutableMap<K1,V2>	AbstractSynchronizedMapIterable.aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
<KK, VV> MutableMap<KK,VV>	AbstractSynchronizedMapIterable.aggregateBy(Function<? super V,? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<KK, VV> MutableMap<KK,VV>	AbstractSynchronizedMapIterable.aggregateInPlaceBy(Function<? super V,? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)

Uses of MutableMap in org.eclipse.collections.impl.map.immutable

Methods in org.eclipse.collections.impl.map.immutable that return MutableMap

Modifier and Type	Method	Description
MutableMap<K,V>	AbstractImmutableMap.toMap()

Uses of MutableMap in org.eclipse.collections.impl.map.mutable

Classes in org.eclipse.collections.impl.map.mutable that implement MutableMap

Modifier and Type	Class	Description
class	AbstractMutableMap<K,V>
class	ConcurrentHashMap<K,V>
class	ConcurrentHashMapUnsafe<K,V>
class	ConcurrentMutableHashMap<K,V>	Deprecated. since 2.0
class	MapAdapter<K,V>	This class provides a MutableMap wrapper around a JDK Collections Map interface instance.
class	SynchronizedMutableMap<K,V>	A synchronized view of a MutableMap.
class	UnifiedMap<K,V>	UnifiedMap stores key/value pairs in a single array, where alternate slots are keys and values.
class	UnmodifiableMutableMap<K,V>	An unmodifiable view of a map.

Methods in org.eclipse.collections.impl.map.mutable that return MutableMap

Modifier and Type	Method	Description
static <K, V> MutableMap<K,V>	MapAdapter.adapt(Map<K,V> map)
<K1, V1, V2> MutableMap<K1,V2>	AbstractMutableMapIterable.aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
<K1, V1, V2> MutableMap<K1,V2>	UnmodifiableMutableMap.aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
<K2, V2> MutableMap<K2,V2>	UnmodifiableMutableMap.aggregateBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V,? extends V2> nonMutatingAggregator)
<K2, V2> MutableMap<K2,V2>	AbstractMutableMapIterable.aggregateInPlaceBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Procedure2<? super V2,? super V> mutatingAggregator)
<K2, V2> MutableMap<K2,V2>	UnmodifiableMutableMap.aggregateInPlaceBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Procedure2<? super V2,? super V> mutatingAggregator)
MutableMap<K,V>	AbstractMutableMap.asSynchronized()
MutableMap<K,V>	SynchronizedMutableMap.asSynchronized()
MutableMap<K,V>	UnmodifiableMutableMap.asSynchronized()
MutableMap<K,V>	AbstractMutableMap.asUnmodifiable()
MutableMap<K,V>	SynchronizedMutableMap.asUnmodifiable()
MutableMap<K,V>	UnmodifiableMutableMap.asUnmodifiable()
abstract MutableMap<K,V>	AbstractMutableMap.clone()
MutableMap<K,V>	ConcurrentHashMap.clone()
MutableMap<K,V>	ConcurrentHashMapUnsafe.clone()
MutableMap<K,V>	ConcurrentMutableHashMap.clone()	Deprecated.
MutableMap<K,V>	MapAdapter.clone()
MutableMap<K,V>	SynchronizedMutableMap.clone()
MutableMap<K,V>	UnmodifiableMutableMap.clone()
<K2, V2> MutableMap<K2,V2>	AbstractMutableMapIterable.collect(Function2<? super K,? super V,Pair<K2,V2>> function)
<K2, V2> MutableMap<K2,V2>	SynchronizedMutableMap.collect(Function2<? super K,? super V,Pair<K2,V2>> pairFunction)
<K2, V2> MutableMap<K2,V2>	UnmodifiableMutableMap.collect(Function2<? super K,? super V,Pair<K2,V2>> function)
<E> MutableMap<K,V>	ConcurrentHashMap.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)
<E> MutableMap<K,V>	ConcurrentHashMapUnsafe.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)
<E> MutableMap<K,V>	ConcurrentMutableHashMap.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)	Deprecated.
<E> MutableMap<K,V>	MapAdapter.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)
<E> MutableMap<K,V>	SynchronizedMutableMap.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> function)
<E> MutableMap<K,V>	UnifiedMap.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)
<E> MutableMap<K,V>	UnmodifiableMutableMap.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)
<R> MutableMap<K,R>	AbstractMutableMap.collectValues(Function2<? super K,? super V,? extends R> function)
<R> MutableMap<K,R>	SynchronizedMutableMap.collectValues(Function2<? super K,? super V,? extends R> function)
<R> MutableMap<K,R>	UnifiedMap.collectValues(Function2<? super K,? super V,? extends R> function)
<R> MutableMap<K,R>	UnmodifiableMutableMap.collectValues(Function2<? super K,? super V,? extends R> function)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.empty()
MutableMap<V,K>	AbstractMutableMapIterable.flipUniqueValues()
MutableMap<V,K>	SynchronizedMutableMap.flipUniqueValues()
MutableMap<V,K>	UnmodifiableMutableMap.flipUniqueValues()
<VV> MutableMap<VV,V>	AbstractMutableMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedMutableMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	UnmodifiableMutableMap.groupByUniqueKey(Function<? super V,? extends VV> function)
abstract <K, V> MutableMap<K,V>	AbstractMutableMap.newEmpty(int capacity)	Creates a new instance of the same type, using the given capacity and the default growth parameters.
MutableMap<K,V>	ConcurrentHashMap.newEmpty()
<K, V> MutableMap<K,V>	ConcurrentHashMap.newEmpty(int capacity)
MutableMap<K,V>	ConcurrentHashMapUnsafe.newEmpty()
<K, V> MutableMap<K,V>	ConcurrentHashMapUnsafe.newEmpty(int capacity)
MutableMap<K,V>	ConcurrentMutableHashMap.newEmpty()	Deprecated.
<K, V> MutableMap<K,V>	ConcurrentMutableHashMap.newEmpty(int capacity)	Deprecated.
MutableMap<K,V>	MapAdapter.newEmpty()
<K, V> MutableMap<K,V>	MapAdapter.newEmpty(int capacity)
MutableMap<K,V>	SynchronizedMutableMap.newEmpty()
MutableMap<K,V>	UnifiedMap.newEmpty()
MutableMap<K,V>	UnifiedMap.newEmpty(int capacity)
MutableMap<K,V>	UnmodifiableMutableMap.newEmpty()
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.of()
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.of(K key, V value)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.of(K key1, V value1, K key2, V value2)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.of(K key1, V value1, K key2, V value2, K key3, V value3)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.of(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.ofInitialCapacity(int capacity)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.ofMap(Map<? extends K,? extends V> map)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.ofMapIterable(MapIterable<? extends K,? extends V> mapIterable)
MutableMap<K,V>	AbstractMutableMap.reject(Predicate2<? super K,? super V> predicate)
MutableMap<K,V>	SynchronizedMutableMap.reject(Predicate2<? super K,? super V> predicate)
MutableMap<K,V>	UnmodifiableMutableMap.reject(Predicate2<? super K,? super V> predicate)
MutableMap<K,V>	AbstractMutableMap.select(Predicate2<? super K,? super V> predicate)
MutableMap<K,V>	SynchronizedMutableMap.select(Predicate2<? super K,? super V> predicate)
MutableMap<K,V>	UnmodifiableMutableMap.select(Predicate2<? super K,? super V> predicate)
MutableMap<K,V>	AbstractMutableMap.tap(Procedure<? super V> procedure)
MutableMap<K,V>	SynchronizedMutableMap.tap(Procedure<? super V> procedure)
MutableMap<K,V>	UnmodifiableMutableMap.tap(Procedure<? super V> procedure)
<NK, NV> MutableMap<NK,NV>	UnmodifiableMutableMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.with()
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.with(K key, V value)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.with(K key1, V value1, K key2, V value2)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.with(K key1, V value1, K key2, V value2, K key3, V value3)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.with(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
MutableMap<K,V>	AbstractMutableMap.withAllKeyValueArguments(Pair<? extends K,? extends V>... keyValues)
MutableMap<K,V>	SynchronizedMutableMap.withAllKeyValueArguments(Pair<? extends K,? extends V>... keyValuePairs)
MutableMap<K,V>	UnmodifiableMutableMap.withAllKeyValueArguments(Pair<? extends K,? extends V>... keyValuePairs)
MutableMap<K,V>	AbstractMutableMap.withAllKeyValues(Iterable<? extends Pair<? extends K,? extends V>> keyValues)
MutableMap<K,V>	SynchronizedMutableMap.withAllKeyValues(Iterable<? extends Pair<? extends K,? extends V>> keyValues)
MutableMap<K,V>	UnmodifiableMutableMap.withAllKeyValues(Iterable<? extends Pair<? extends K,? extends V>> keyValues)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.withInitialCapacity(int capacity)
MutableMap<K,V>	AbstractMutableMap.withKeyValue(K key, V value)
MutableMap<K,V>	SynchronizedMutableMap.withKeyValue(K key, V value)
MutableMap<K,V>	UnmodifiableMutableMap.withKeyValue(K key, V value)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.withMap(Map<? extends K,? extends V> map)
MutableMap<K,V>	SynchronizedMutableMap.withMap(Map<? extends K,? extends V> map)
MutableMap<K,V>	UnmodifiableMutableMap.withMap(Map<? extends K,? extends V> map)
<K, V> MutableMap<K,V>	MutableMapFactoryImpl.withMapIterable(MapIterable<? extends K,? extends V> mapIterable)
MutableMap<K,V>	AbstractMutableMap.withoutAllKeys(Iterable<? extends K> keys)
MutableMap<K,V>	SynchronizedMutableMap.withoutAllKeys(Iterable<? extends K> keys)
MutableMap<K,V>	UnmodifiableMutableMap.withoutAllKeys(Iterable<? extends K> keys)
MutableMap<K,V>	AbstractMutableMap.withoutKey(K key)
MutableMap<K,V>	SynchronizedMutableMap.withoutKey(K key)
MutableMap<K,V>	UnmodifiableMutableMap.withoutKey(K key)

Constructors in org.eclipse.collections.impl.map.mutable with parameters of type MutableMap

Constructor	Description
SynchronizedMutableMap(MutableMap<K,V> newMap)
SynchronizedMutableMap(MutableMap<K,V> newMap, Object newLock)

Uses of MutableMap in org.eclipse.collections.impl.map.mutable.primitive

Methods in org.eclipse.collections.impl.map.mutable.primitive that return MutableMap

Modifier and Type	Method	Description
<K, VV> MutableMap<K,VV>	SynchronizedByteObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedCharObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedDoubleObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedFloatObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedIntObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedLongObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedShortObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableByteObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableCharObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableDoubleObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableFloatObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableIntObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableLongObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableShortObjectMap.aggregateBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K, VV> MutableMap<K,VV>	ByteObjectHashMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	CharObjectHashMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	DoubleObjectHashMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	FloatObjectHashMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	IntObjectHashMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	LongObjectHashMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	ShortObjectHashMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedByteObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedCharObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedDoubleObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedFloatObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedIntObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedLongObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	SynchronizedShortObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableByteObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableCharObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableDoubleObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableFloatObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableIntObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableLongObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<K, VV> MutableMap<K,VV>	UnmodifiableShortObjectMap.aggregateInPlaceBy(Function<? super V,? extends K> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<VV> MutableMap<VV,V>	ByteObjectHashMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	CharObjectHashMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	DoubleObjectHashMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	FloatObjectHashMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	IntObjectHashMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	LongObjectHashMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	ShortObjectHashMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedByteObjectMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedCharObjectMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedDoubleObjectMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedFloatObjectMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedIntObjectMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedLongObjectMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedShortObjectMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<V1> MutableMap<V1,V>	UnmodifiableByteObjectMap.groupByUniqueKey(Function<? super V,? extends V1> function)
<V1> MutableMap<V1,V>	UnmodifiableCharObjectMap.groupByUniqueKey(Function<? super V,? extends V1> function)
<V1> MutableMap<V1,V>	UnmodifiableDoubleObjectMap.groupByUniqueKey(Function<? super V,? extends V1> function)
<V1> MutableMap<V1,V>	UnmodifiableFloatObjectMap.groupByUniqueKey(Function<? super V,? extends V1> function)
<V1> MutableMap<V1,V>	UnmodifiableIntObjectMap.groupByUniqueKey(Function<? super V,? extends V1> function)
<V1> MutableMap<V1,V>	UnmodifiableLongObjectMap.groupByUniqueKey(Function<? super V,? extends V1> function)
<V1> MutableMap<V1,V>	UnmodifiableShortObjectMap.groupByUniqueKey(Function<? super V,? extends V1> function)
<NK, NV> MutableMap<NK,NV>	ByteObjectHashMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	CharObjectHashMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	DoubleObjectHashMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	FloatObjectHashMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	IntObjectHashMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	LongObjectHashMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	ShortObjectHashMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	SynchronizedByteObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	SynchronizedCharObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	SynchronizedDoubleObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	SynchronizedFloatObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	SynchronizedIntObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	SynchronizedLongObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	SynchronizedShortObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableByteObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableCharObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableDoubleObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableFloatObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableIntObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableLongObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableShortObjectMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.map.ordered.mutable

Methods in org.eclipse.collections.impl.map.ordered.mutable that return MutableMap

Modifier and Type	Method	Description
<K2, V2> MutableMap<K2,V2>	OrderedMapAdapter.aggregateBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V,? extends V2> nonMutatingAggregator)
<K1, V1, V2> MutableMap<K1,V2>	UnmodifiableMutableOrderedMap.aggregateBy(Function<? super K,? extends K1> keyFunction, Function<? super V,? extends V1> valueFunction, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V1,? extends V2> nonMutatingAggregator)
<KK, VV> MutableMap<KK,VV>	UnmodifiableMutableOrderedMap.aggregateBy(Function<? super V,? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Function2<? super VV,? super V,? extends VV> nonMutatingAggregator)
<K2, V2> MutableMap<K2,V2>	OrderedMapAdapter.aggregateInPlaceBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Procedure2<? super V2,? super V> mutatingAggregator)
<KK, VV> MutableMap<KK,VV>	UnmodifiableMutableOrderedMap.aggregateInPlaceBy(Function<? super V,? extends KK> groupBy, Function0<? extends VV> zeroValueFactory, Procedure2<? super VV,? super V> mutatingAggregator)
<NK, NV> MutableMap<NK,NV>	UnmodifiableMutableOrderedMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.map.sorted.mutable

Methods in org.eclipse.collections.impl.map.sorted.mutable that return MutableMap

Modifier and Type	Method	Description
<K2, V2> MutableMap<K2,V2>	UnmodifiableTreeMap.aggregateBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Function2<? super V2,? super V,? extends V2> nonMutatingAggregator)
<K2, V2> MutableMap<K2,V2>	UnmodifiableTreeMap.aggregateInPlaceBy(Function<? super V,? extends K2> groupBy, Function0<? extends V2> zeroValueFactory, Procedure2<? super V2,? super V> mutatingAggregator)
<K2, V2> MutableMap<K2,V2>	SynchronizedSortedMap.collect(Function2<? super K,? super V,Pair<K2,V2>> function)
<K2, V2> MutableMap<K2,V2>	UnmodifiableTreeMap.collect(Function2<? super K,? super V,Pair<K2,V2>> function)
<VV> MutableMap<VV,V>	AbstractMutableSortedMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	SynchronizedSortedMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<VV> MutableMap<VV,V>	UnmodifiableTreeMap.groupByUniqueKey(Function<? super V,? extends VV> function)
<NK, NV> MutableMap<NK,NV>	UnmodifiableTreeMap.toMap(Function<? super V,? extends NK> keyFunction, Function<? super V,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.map.strategy.mutable

Classes in org.eclipse.collections.impl.map.strategy.mutable that implement MutableMap

Modifier and Type	Class	Description
class	UnifiedMapWithHashingStrategy<K,V>	UnifiedMapWithHashingStrategy stores key/value pairs in a single array, where alternate slots are keys and values.

Methods in org.eclipse.collections.impl.map.strategy.mutable that return MutableMap

Modifier and Type	Method	Description
<E> MutableMap<K,V>	UnifiedMapWithHashingStrategy.collectKeysAndValues(Iterable<E> iterable, Function<? super E,? extends K> keyFunction, Function<? super E,? extends V> valueFunction)
<R> MutableMap<K,R>	UnifiedMapWithHashingStrategy.collectValues(Function2<? super K,? super V,? extends R> function)
MutableMap<K,V>	UnifiedMapWithHashingStrategy.newEmpty()
MutableMap<K,V>	UnifiedMapWithHashingStrategy.newEmpty(int capacity)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.of(HashingStrategy<? super K> hashingStrategy)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.of(HashingStrategy<? super K> hashingStrategy, K key, V value)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.of(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.of(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2, K key3, V value3)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.of(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.with(HashingStrategy<? super K> hashingStrategy)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.with(HashingStrategy<? super K> hashingStrategy, K key, V value)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.with(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.with(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2, K key3, V value3)
<K, V> MutableMap<K,V>	MutableHashingStrategyMapFactoryImpl.with(HashingStrategy<? super K> hashingStrategy, K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)

Uses of MutableMap in org.eclipse.collections.impl.multimap

Methods in org.eclipse.collections.impl.multimap that return MutableMap

Modifier and Type	Method	Description
MutableMap<K,RichIterable<V>>	AbstractImmutableMultimap.toMap()
<R extends Collection<V>> MutableMap<K,R>	AbstractImmutableMultimap.toMap(Function0<R> collectionFactory)
MutableMap<K,RichIterable<V>>	AbstractMutableMultimap.toMap()
<R extends Collection<V>> MutableMap<K,R>	AbstractMutableMultimap.toMap(Function0<R> collectionFactory)
MutableMap<K,RichIterable<V>>	AbstractSynchronizedMultimap.toMap()
<R extends Collection<V>> MutableMap<K,R>	AbstractSynchronizedMultimap.toMap(Function0<R> collectionFactory)

Uses of MutableMap in org.eclipse.collections.impl.multimap.bag

Constructors in org.eclipse.collections.impl.multimap.bag with parameters of type MutableMap

Constructor	Description
ImmutableBagMultimapImpl(MutableMap<K,ImmutableBag<V>> map)

Uses of MutableMap in org.eclipse.collections.impl.multimap.bag.sorted.immutable

Constructors in org.eclipse.collections.impl.multimap.bag.sorted.immutable with parameters of type MutableMap

Constructor	Description
ImmutableSortedBagMultimapImpl(MutableMap<K,ImmutableSortedBag<V>> map, Comparator<? super V> comparator)

Uses of MutableMap in org.eclipse.collections.impl.multimap.list

Constructors in org.eclipse.collections.impl.multimap.list with parameters of type MutableMap

Constructor	Description
ImmutableListMultimapImpl(MutableMap<K,ImmutableList<V>> map)

Uses of MutableMap in org.eclipse.collections.impl.multimap.set

Constructors in org.eclipse.collections.impl.multimap.set with parameters of type MutableMap

Constructor	Description
ImmutableSetMultimapImpl(MutableMap<K,ImmutableSet<V>> map)

Uses of MutableMap in org.eclipse.collections.impl.multimap.set.sorted

Constructors in org.eclipse.collections.impl.multimap.set.sorted with parameters of type MutableMap

Constructor	Description
ImmutableSortedSetMultimapImpl(MutableMap<K,ImmutableSortedSet<V>> map, Comparator<? super V> comparator)

Uses of MutableMap in org.eclipse.collections.impl.parallel

Methods in org.eclipse.collections.impl.parallel that return MutableMap

Modifier and Type	Method	Description
static <T, K, V> MutableMap<K,V>	ParallelIterate.aggregateBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
static <T, K, V> MutableMap<K,V>	ParallelIterate.aggregateBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator, int batchSize)
static <T, K, V> MutableMap<K,V>	ParallelIterate.aggregateBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator, int batchSize, Executor executor)
static <T, K, V> MutableMap<K,V>	ParallelIterate.aggregateInPlaceBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
static <T, K, V> MutableMap<K,V>	ParallelIterate.aggregateInPlaceBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator, int batchSize)
static <T, K, V> MutableMap<K,V>	ParallelIterate.aggregateInPlaceBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator, int batchSize, Executor executor)
static <V, T> MutableMap<V,BigDecimal>	ParallelIterate.sumByBigDecimal(Iterable<T> iterable, Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)
static <V, T> MutableMap<V,BigInteger>	ParallelIterate.sumByBigInteger(Iterable<T> iterable, Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)

Uses of MutableMap in org.eclipse.collections.impl.set

Methods in org.eclipse.collections.impl.set that return MutableMap

Modifier and Type	Method	Description
<V> MutableMap<V,T>	AbstractUnifiedSet.groupByUniqueKey(Function<? super T,? extends V> function)

Uses of MutableMap in org.eclipse.collections.impl.set.mutable

Methods in org.eclipse.collections.impl.set.mutable that return MutableMap

Modifier and Type	Method	Description
<V> MutableMap<V,T>	MultiReaderUnifiedSet.groupByUniqueKey(Function<? super T,? extends V> function)

Uses of MutableMap in org.eclipse.collections.impl.stack.mutable

Methods in org.eclipse.collections.impl.stack.mutable that return MutableMap

Modifier and Type	Method	Description
<K, V> MutableMap<K,V>	SynchronizedStack.aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
<K, V> MutableMap<K,V>	UnmodifiableStack.aggregateBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
<K, V> MutableMap<K,V>	ArrayStack.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<K, V> MutableMap<K,V>	SynchronizedStack.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<K, V> MutableMap<K,V>	UnmodifiableStack.aggregateInPlaceBy(Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
<V> MutableMap<V,T>	ArrayStack.groupByUniqueKey(Function<? super T,? extends V> function)
<V> MutableMap<V,T>	SynchronizedStack.groupByUniqueKey(Function<? super T,? extends V> function)
<V> MutableMap<V,T>	UnmodifiableStack.groupByUniqueKey(Function<? super T,? extends V> function)
<NK, NV> MutableMap<NK,NV>	ArrayStack.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	SynchronizedStack.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)
<NK, NV> MutableMap<NK,NV>	UnmodifiableStack.toMap(Function<? super T,? extends NK> keyFunction, Function<? super T,? extends NV> valueFunction)

Uses of MutableMap in org.eclipse.collections.impl.utility

Methods in org.eclipse.collections.impl.utility that return MutableMap

Modifier and Type	Method	Description
static <T, K, V> MutableMap<K,V>	ArrayListIterate.aggregateBy(ArrayList<T> list, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
static <T, K, V> MutableMap<K,V>	Iterate.aggregateBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
static <T, K, V> MutableMap<K,V>	ArrayListIterate.aggregateInPlaceBy(ArrayList<T> list, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
static <T, K, V> MutableMap<K,V>	Iterate.aggregateInPlaceBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
static <K, V, K2, V2> MutableMap<K2,V2>	MapIterate.collect(Map<K,V> map, Function2<? super K,? super V,Pair<K2,V2>> function)	For each value of the map, the function is evaluated with the key and value as the parameter.
static <K1, V1, K2, V2> MutableMap<K2,V2>	MapIterate.collect(Map<K1,V1> map, Function<? super K1,? extends K2> keyFunction, Function<? super V1,? extends V2> valueFunction)	For each key-value entry of a map, applies a function to each, and adds the transformed entry to a new Map.
static <K1, V1, K2, V2> MutableMap<K2,V2>	MapIterate.collect(Map<K1,V1> map, Function<? super K1,? extends K2> keyFunction, Function<? super V1,? extends V2> valueFunction, Map<K2,V2> target)	For each key-value entry of a map, applies a function to each, and adds the transformed entry to the target Map.
static <K1, V1, K2, V2> MutableMap<K2,V2>	MapIterate.collectIf(Map<K1,V1> map, Function2<? super K1,? super V1,Pair<K2,V2>> function, Predicate2<? super K1,? super V1> predicate)	For each value of the map, the Predicate2 is evaluated with the key and value as the parameter, and if true, then function is applied.
static <K1, V1, K2, V2> MutableMap<K2,V2>	MapIterate.collectIf(Map<K1,V1> map, Function2<? super K1,? super V1,Pair<K2,V2>> function, Predicate2<? super K1,? super V1> predicate, Map<K2,V2> target)	For each value of the map, the Predicate2 is evaluated with the key and value as the parameter, and if true, then function is applied.
static <K, V, V2> MutableMap<K,V2>	MapIterate.collectValues(Map<K,V> map, Function2<? super K,? super V,? extends V2> function)	For each key and value of the map, the function is evaluated with the key and value as the parameter.
static <K, V> MutableMap<V,K>	MapIterate.flipUniqueValues(MapIterable<K,V> mapIterable)
static <T, V> MutableMap<V,T>	ArrayListIterate.groupByUniqueKey(ArrayList<T> list, Function<? super T,? extends V> function)
static <V, T> MutableMap<V,T>	Iterate.groupByUniqueKey(Iterable<T> iterable, Function<? super T,? extends V> function)
static <K, T> MutableMap<K,T>	ListIterate.groupByUniqueKey(List<T> list, Function<? super T,? extends K> function)
static <K, V> MutableMap<K,V>	MapIterate.rejectMapOnEntry(Map<K,V> map, Predicate2<? super K,? super V> predicate)	For each value of the map, predicate is evaluated with the element as the parameter.
static <K, V> MutableMap<V,K>	MapIterate.reverseMapping(Map<K,V> map)	Return a new map swapping key-value for value-key.
static <K, V> MutableMap<K,V>	MapIterate.selectMapOnEntry(Map<K,V> map, Predicate2<? super K,? super V> predicate)	For each entry of the source map, the Predicate2 is evaluated.
static <K, V> MutableMap<K,V>	MapIterate.selectMapOnKey(Map<K,V> map, Predicate<? super K> predicate)	For each key of the source map, the Predicate is evaluated.
static <K, V> MutableMap<K,V>	MapIterate.selectMapOnValue(Map<K,V> map, Predicate<? super V> predicate)	For each value of the source map, the Predicate is evaluated.
static <V, T> MutableMap<V,BigDecimal>	ArrayIterate.sumByBigDecimal(T[] array, Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)
static <V, T> MutableMap<V,BigDecimal>	Iterate.sumByBigDecimal(Iterable<T> iterable, Function<T,V> groupBy, Function<? super T,BigDecimal> function)	Groups and sums the values of the iterable using the two specified functions.
static <V, T> MutableMap<V,BigDecimal>	ListIterate.sumByBigDecimal(List<T> list, Function<T,V> groupBy, Function<? super T,BigDecimal> function)
static <V, T> MutableMap<V,BigInteger>	ArrayIterate.sumByBigInteger(T[] array, Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)
static <V, T> MutableMap<V,BigInteger>	Iterate.sumByBigInteger(Iterable<T> iterable, Function<T,V> groupBy, Function<? super T,BigInteger> function)	Groups and sums the values of the iterable using the two specified functions.
static <V, T> MutableMap<V,BigInteger>	ListIterate.sumByBigInteger(List<T> list, Function<T,V> groupBy, Function<? super T,BigInteger> function)
static MutableMap<String,String>	StringIterate.tokensToMap(String string)	Converts a string of tokens to a MutableMap using a | to separate pairs, and a : to separate key and value.
static MutableMap<String,String>	StringIterate.tokensToMap(String string, String pairSeparator, String keyValueSeparator)	Converts a string of tokens to a MutableMap using the specified separators.
static <K, V> MutableMap<K,V>	StringIterate.tokensToMap(String string, String separator, String keyValueSeparator, Function<String,K> keyFunction, Function<String,V> valueFunction)	Converts a string of tokens to a MutableMap using the specified 'key' and 'value' Functions.
static <T, K, V> MutableMap<K,V>	ArrayIterate.toMap(T[] objectArray, Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)	Iterate over the specified array applying the specified Functions to each element to calculate a key and value, and return the results as a Map.
static <K, V> MutableMap<K,V>	ArrayIterate.toMap(V[] objectArray, Function<? super V,? extends K> keyFunction)	Iterate over the specified array applying the specified Function to each element to calculate a key and return the results as a HashMap.
static <T, K> MutableMap<K,T>	Iterate.toMap(Iterable<T> iterable, Function<? super T,? extends K> keyFunction)	Iterate over the specified collection applying the specified Function to each element to calculate a key and return the results as a Map.
static <T, K, V> MutableMap<K,V>	Iterate.toMap(Iterable<T> iterable, Function<? super T,? extends K> keyFunction, Function<? super T,? extends V> valueFunction)	Iterate over the specified collection applying the specified Functions to each element to calculate a key and value, and return the results as a Map.

Uses of MutableMap in org.eclipse.collections.impl.utility.internal

Methods in org.eclipse.collections.impl.utility.internal that return MutableMap

Modifier and Type	Method	Description
static <T, K, V> MutableMap<K,V>	IterableIterate.aggregateBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
static <T, K, V> MutableMap<K,V>	IteratorIterate.aggregateBy(Iterator<T> iterator, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
static <T, K, V> MutableMap<K,V>	IteratorIterate.aggregateBy(Iterator<T> iterator, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
static <T, K, V> MutableMap<K,V>	RandomAccessListIterate.aggregateBy(List<T> list, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Function2<? super V,? super T,? extends V> nonMutatingAggregator)
static <T, K, V> MutableMap<K,V>	IterableIterate.aggregateInPlaceBy(Iterable<T> iterable, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
static <T, K, V> MutableMap<K,V>	RandomAccessListIterate.aggregateInPlaceBy(List<T> list, Function<? super T,? extends K> groupBy, Function0<? extends V> zeroValueFactory, Procedure2<? super V,? super T> mutatingAggregator)
static <K, T> MutableMap<K,T>	IterableIterate.groupByUniqueKey(Iterable<T> iterable, Function<? super T,? extends K> function)
static <K, T> MutableMap<K,T>	RandomAccessListIterate.groupByUniqueKey(List<T> list, Function<? super T,? extends K> function)
static <V, T> MutableMap<V,BigDecimal>	IterableIterate.sumByBigDecimal(Iterable<T> iterable, Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)
static <V, T> MutableMap<V,BigDecimal>	IteratorIterate.sumByBigDecimal(Iterator<T> iterator, Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)
static <V, T> MutableMap<V,BigDecimal>	RandomAccessListIterate.sumByBigDecimal(List<T> list, Function<? super T,? extends V> groupBy, Function<? super T,BigDecimal> function)
static <V, T> MutableMap<V,BigInteger>	IterableIterate.sumByBigInteger(Iterable<T> iterable, Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)
static <V, T> MutableMap<V,BigInteger>	IteratorIterate.sumByBigInteger(Iterator<T> iterator, Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)
static <V, T> MutableMap<V,BigInteger>	RandomAccessListIterate.sumByBigInteger(List<T> list, Function<? super T,? extends V> groupBy, Function<? super T,BigInteger> function)