org.eclipse.collections.impl.map.mutable

Class ConcurrentHashMapUnsafe<K,V>

java.lang.Object

org.eclipse.collections.impl.AbstractRichIterable<V>

org.eclipse.collections.impl.map.AbstractMapIterable<K,V>

org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable<K,V>

org.eclipse.collections.impl.map.mutable.AbstractMutableMap<K,V>

org.eclipse.collections.impl.map.mutable.ConcurrentHashMapUnsafe<K,V>

All Implemented Interfaces:

Externalizable, Serializable, Cloneable, Iterable<V>, ConcurrentMap<K,V>, Map<K,V>, org.eclipse.collections.api.InternalIterable<V>, org.eclipse.collections.api.map.ConcurrentMutableMap<K,V>, org.eclipse.collections.api.map.MapIterable<K,V>, org.eclipse.collections.api.map.MutableMap<K,V>, org.eclipse.collections.api.map.MutableMapIterable<K,V>, org.eclipse.collections.api.map.UnsortedMapIterable<K,V>, org.eclipse.collections.api.RichIterable<V>

public class ConcurrentHashMapUnsafe<K,V>
extends AbstractMutableMap<K,V>
implements org.eclipse.collections.api.map.ConcurrentMutableMap<K,V>, Externalizable

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
ConcurrentHashMapUnsafe()
ConcurrentHashMapUnsafe(int initialCapacity)

Method Summary

Modifier and Type	Method and Description
void	clear()
org.eclipse.collections.api.map.MutableMap<K,V>	clone()
<E> org.eclipse.collections.api.map.MutableMap<K,V>	collectKeysAndValues(Iterable<E> iterable, org.eclipse.collections.api.block.function.Function<? super E,? extends K> keyFunction, org.eclipse.collections.api.block.function.Function<? super E,? extends V> valueFunction)
boolean	containsKey(Object key)
boolean	containsValue(Object value)
int	countEntries()
Set<Map.Entry<K,V>>	entrySet()
boolean	equals(Object o)
void	forEachKey(org.eclipse.collections.api.block.procedure.Procedure<? super K> procedure)
void	forEachKeyValue(org.eclipse.collections.api.block.procedure.Procedure2<? super K,? super V> procedure)
void	forEachValue(org.eclipse.collections.api.block.procedure.Procedure<? super V> procedure)
<P> void	forEachWith(org.eclipse.collections.api.block.procedure.Procedure2<? super V,? super P> procedure, P parameter)
void	forEachWithIndex(org.eclipse.collections.api.block.procedure.primitive.ObjectIntProcedure<? super V> objectIntProcedure)
V	get(Object key)
V	getIfAbsent(K key, org.eclipse.collections.api.block.function.Function0<? extends V> function)
V	getIfAbsentPut(K key, org.eclipse.collections.api.block.function.Function<? super K,? extends V> factory)
V	getIfAbsentPut(K key, org.eclipse.collections.api.block.function.Function0<? extends V> factory)
V	getIfAbsentPut(K key, V value)
<P> V	getIfAbsentPutWith(K key, org.eclipse.collections.api.block.function.Function<? super P,? extends V> function, P parameter)
<P> V	getIfAbsentWith(K key, org.eclipse.collections.api.block.function.Function<? super P,? extends V> function, P parameter)
int	hashCode()
<A> A	ifPresentApply(K key, org.eclipse.collections.api.block.function.Function<? super V,? extends A> function)
boolean	isEmpty()
Iterator<V>	iterator()
Set<K>	keySet()
org.eclipse.collections.api.map.MutableMap<K,V>	newEmpty()
<K,V> org.eclipse.collections.api.map.MutableMap<K,V>	newEmpty(int capacity) Creates a new instance of the same type, using the given capacity and the default growth parameters.
static <K,V> ConcurrentHashMapUnsafe<K,V>	newMap()
static <K,V> ConcurrentHashMapUnsafe<K,V>	newMap(int newSize)
static <NK,NV> ConcurrentHashMapUnsafe<NK,NV>	newMap(Map<NK,NV> map)
boolean	notEmpty()
void	parallelForEachKeyValue(List<org.eclipse.collections.api.block.procedure.Procedure2<K,V>> blocks, Executor executor)
void	parallelForEachValue(List<org.eclipse.collections.api.block.procedure.Procedure<V>> blocks, Executor executor)
V	put(K key, V value)
void	putAll(Map<? extends K,? extends V> map)
void	putAllInParallel(Map<K,V> map, int chunks, Executor executor)
V	putIfAbsent(K key, V value)
<P1,P2> V	putIfAbsentGetIfPresent(K key, org.eclipse.collections.api.block.function.Function2<K,V,K> keyTransformer, org.eclipse.collections.api.block.function.Function3<P1,P2,K,V> factory, P1 param1, P2 param2) It puts an object into the map based on the key.
void	readExternal(ObjectInput in)
V	remove(Object key)
boolean	remove(Object key, Object value)
V	removeKey(K key)
V	replace(K key, V value)
boolean	replace(K key, V oldValue, V newValue)
int	size()
org.eclipse.collections.api.map.ImmutableMap<K,V>	toImmutable()
String	toString() Returns a string representation of this collection.
V	updateValue(K key, org.eclipse.collections.api.block.function.Function0<? extends V> factory, org.eclipse.collections.api.block.function.Function<? super V,? extends V> function)
<P> V	updateValueWith(K key, org.eclipse.collections.api.block.function.Function0<? extends V> factory, org.eclipse.collections.api.block.function.Function2<? super V,? super P,? extends V> function, P parameter)
Collection<V>	values()
ConcurrentHashMapUnsafe<K,V>	withAllKeyValueArguments(org.eclipse.collections.api.tuple.Pair<? extends K,? extends V>... keyValues)
ConcurrentHashMapUnsafe<K,V>	withAllKeyValues(Iterable<? extends org.eclipse.collections.api.tuple.Pair<? extends K,? extends V>> keyValues)
ConcurrentHashMapUnsafe<K,V>	withKeyValue(K key, V value)
ConcurrentHashMapUnsafe<K,V>	withoutAllKeys(Iterable<? extends K> keys)
ConcurrentHashMapUnsafe<K,V>	withoutKey(K key)
void	writeExternal(ObjectOutput out)

Methods inherited from class org.eclipse.collections.impl.map.mutable.AbstractMutableMap

asSynchronized, asUnmodifiable, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectValues, collectWith, flatCollect, flip, groupBy, groupByEach, partition, partitionWith, reject, reject, rejectWith, select, select, selectInstancesOf, selectWith, tap, zip, zipWithIndex

Methods inherited from class org.eclipse.collections.impl.map.mutable.AbstractMutableMapIterable

add, aggregateBy, aggregateInPlaceBy, collect, detect, flipUniqueValues, getIfAbsentPutWithKey, groupByUniqueKey, keysView, keyValuesView, valuesView

Methods inherited from class org.eclipse.collections.impl.map.AbstractMapIterable

allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, asLazy, chunk, contains, detect, detectIfNone, detectWith, detectWithIfNone, each, getFirst, getIfAbsentValue, getLast, noneSatisfy, noneSatisfyWith, toArray, toArray

Methods inherited from class org.eclipse.collections.impl.AbstractRichIterable

appendString, appendString, appendString, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, containsAll, containsAllArguments, containsAllIterable, count, countWith, flatCollect, forEach, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, reject, rejectWith, select, selectWith, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndex

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.collections.api.map.MutableMap

aggregateBy, aggregateInPlaceBy, asSynchronized, asUnmodifiable, collect, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectValues, collectWith, flatCollect, flip, flipUniqueValues, groupBy, groupByEach, groupByUniqueKey, partition, partitionWith, reject, reject, rejectWith, select, select, selectInstancesOf, selectWith, tap, zip, zipWithIndex

Methods inherited from interface org.eclipse.collections.api.map.MutableMapIterable

add, getIfAbsentPutWithKey

Methods inherited from interface java.util.Map

compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface org.eclipse.collections.api.map.MapIterable

detect, getIfAbsentValue, keysView, keyValuesView, valuesView

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

allSatisfy, allSatisfyWith, anySatisfy, anySatisfyWith, appendString, appendString, appendString, asLazy, chunk, collect, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectIf, collectInt, collectLong, collectShort, collectWith, contains, containsAll, containsAllArguments, containsAllIterable, count, countWith, detect, detectIfNone, detectWith, detectWithIfNone, each, flatCollect, getFirst, getLast, groupBy, groupByEach, groupByUniqueKey, injectInto, injectInto, injectInto, injectInto, injectInto, makeString, makeString, makeString, max, max, maxBy, min, min, minBy, noneSatisfy, noneSatisfyWith, reject, rejectWith, select, selectWith, sumByDouble, sumByFloat, sumByInt, sumByLong, sumOfDouble, sumOfFloat, sumOfInt, sumOfLong, toArray, toArray, toBag, toList, toMap, toSet, toSortedBag, toSortedBag, toSortedBagBy, toSortedList, toSortedList, toSortedListBy, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toSortedSetBy, zip, zipWithIndex

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

forEach

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Methods inherited from interface java.util.concurrent.ConcurrentMap

compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Constructor Detail

ConcurrentHashMapUnsafe

public ConcurrentHashMapUnsafe()

ConcurrentHashMapUnsafe

public ConcurrentHashMapUnsafe(int initialCapacity)

Method Detail

newMap

public static <K,V> ConcurrentHashMapUnsafe<K,V> newMap()

newMap

public static <K,V> ConcurrentHashMapUnsafe<K,V> newMap(int newSize)

putIfAbsent

public V putIfAbsent(K key,
                     V value)

Specified by:

putIfAbsent in interface ConcurrentMap<K,V>

Specified by:

putIfAbsent in interface Map<K,V>

countEntries

public int countEntries()

getIfAbsentPut

public V getIfAbsentPut(K key,
                        org.eclipse.collections.api.block.function.Function<? super K,? extends V> factory)

getIfAbsentPut

public V getIfAbsentPut(K key,
                        org.eclipse.collections.api.block.function.Function0<? extends V> factory)

Specified by:

getIfAbsentPut in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

getIfAbsentPut in class AbstractMutableMapIterable<K,V>

getIfAbsentPut

public V getIfAbsentPut(K key,
                        V value)

Specified by:

getIfAbsentPut in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

getIfAbsentPut in class AbstractMutableMapIterable<K,V>

putIfAbsentGetIfPresent

public <P1,P2> V putIfAbsentGetIfPresent(K key,
                                         org.eclipse.collections.api.block.function.Function2<K,V,K> keyTransformer,
                                         org.eclipse.collections.api.block.function.Function3<P1,P2,K,V> factory,
                                         P1 param1,
                                         P2 param2)

It puts an object into the map based on the key. It uses a copy of the key converted by transformer.

Parameters:

key - The "mutable" key, which has the same identity/hashcode as the inserted key, only during this call

keyTransformer - If the record is absent, the transformer will transform the "mutable" key into an immutable copy of the key. Note that the transformed key must have the same identity/hashcode as the original "mutable" key.

factory - It creates an object, if it is not present in the map already.

remove

public boolean remove(Object key,
                      Object value)

Specified by:

remove in interface ConcurrentMap<K,V>

Specified by:

remove in interface Map<K,V>

size

public int size()

Specified by:

size in interface Map<K,V>

Specified by:

size in interface org.eclipse.collections.api.RichIterable<V>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Map<K,V>

Specified by:

isEmpty in interface org.eclipse.collections.api.RichIterable<V>

Overrides:

isEmpty in class AbstractRichIterable<V>

containsKey

public boolean containsKey(Object key)

Specified by:

containsKey in interface Map<K,V>

Specified by:

containsKey in interface org.eclipse.collections.api.map.MapIterable<K,V>

containsValue

public boolean containsValue(Object value)

Specified by:

containsValue in interface Map<K,V>

Specified by:

containsValue in interface org.eclipse.collections.api.map.MapIterable<K,V>

get

public V get(Object key)

Specified by:

get in interface Map<K,V>

Specified by:

get in interface org.eclipse.collections.api.map.MapIterable<K,V>

put

public V put(K key,
             V value)

Specified by:

put in interface Map<K,V>

putAllInParallel

public void putAllInParallel(Map<K,V> map,
                             int chunks,
                             Executor executor)

putAll

public void putAll(Map<? extends K,? extends V> map)

Specified by:

putAll in interface Map<K,V>

clear

public void clear()

Specified by:

clear in interface Map<K,V>

keySet

public Set<K> keySet()

Specified by:

keySet in interface Map<K,V>

values

public Collection<V> values()

Specified by:

values in interface Map<K,V>

entrySet

public Set<Map.Entry<K,V>> entrySet()

Specified by:

entrySet in interface Map<K,V>

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

replace

public V replace(K key,
                 V value)

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

remove

public V remove(Object key)

Specified by:

remove in interface Map<K,V>

parallelForEachKeyValue

public void parallelForEachKeyValue(List<org.eclipse.collections.api.block.procedure.Procedure2<K,V>> blocks,
                                    Executor executor)

parallelForEachValue

public void parallelForEachValue(List<org.eclipse.collections.api.block.procedure.Procedure<V>> blocks,
                                 Executor executor)

hashCode

public int hashCode()

Specified by:

hashCode in interface Map<K,V>

Specified by:

hashCode in interface org.eclipse.collections.api.map.MapIterable<K,V>

Overrides:

hashCode in class Object

equals

public boolean equals(Object o)

Specified by:

equals in interface Map<K,V>

Specified by:

equals in interface org.eclipse.collections.api.map.MapIterable<K,V>

Overrides:

equals in class Object

toString

public String toString()

Description copied from class: AbstractRichIterable

Returns a string representation of this collection. The string representation consists of a list of the collection's elements in the order they are returned by its iterator, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (comma and space). Elements are converted to strings as by String.valueOf(Object).

This implementation creates an empty string buffer, appends a left square bracket, and iterates over the collection appending the string representation of each element in turn. After appending each element except the last, the string ", " is appended. Finally a right bracket is appended. A string is obtained from the string buffer, and returned.

Specified by:

toString in interface org.eclipse.collections.api.map.MapIterable<K,V>

Specified by:

toString in interface org.eclipse.collections.api.RichIterable<V>

Overrides:

toString in class AbstractRichIterable<V>

Returns:

a string representation of this collection.

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Specified by:

readExternal in interface Externalizable

Throws:

IOException

ClassNotFoundException

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Specified by:

writeExternal in interface Externalizable

Throws:

IOException

newMap

public static <NK,NV> ConcurrentHashMapUnsafe<NK,NV> newMap(Map<NK,NV> map)

withKeyValue

public ConcurrentHashMapUnsafe<K,V> withKeyValue(K key,
                                                 V value)

Specified by:

withKeyValue in interface org.eclipse.collections.api.map.MutableMap<K,V>

Specified by:

withKeyValue in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

withKeyValue in class AbstractMutableMap<K,V>

withAllKeyValues

public ConcurrentHashMapUnsafe<K,V> withAllKeyValues(Iterable<? extends org.eclipse.collections.api.tuple.Pair<? extends K,? extends V>> keyValues)

Specified by:

withAllKeyValues in interface org.eclipse.collections.api.map.MutableMap<K,V>

Specified by:

withAllKeyValues in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

withAllKeyValues in class AbstractMutableMap<K,V>

withAllKeyValueArguments

public ConcurrentHashMapUnsafe<K,V> withAllKeyValueArguments(org.eclipse.collections.api.tuple.Pair<? extends K,? extends V>... keyValues)

Specified by:

withAllKeyValueArguments in interface org.eclipse.collections.api.map.MutableMap<K,V>

Specified by:

withAllKeyValueArguments in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

withAllKeyValueArguments in class AbstractMutableMap<K,V>

withoutKey

public ConcurrentHashMapUnsafe<K,V> withoutKey(K key)

Specified by:

withoutKey in interface org.eclipse.collections.api.map.MutableMap<K,V>

Specified by:

withoutKey in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

withoutKey in class AbstractMutableMap<K,V>

withoutAllKeys

public ConcurrentHashMapUnsafe<K,V> withoutAllKeys(Iterable<? extends K> keys)

Specified by:

withoutAllKeys in interface org.eclipse.collections.api.map.MutableMap<K,V>

Specified by:

withoutAllKeys in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

withoutAllKeys in class AbstractMutableMap<K,V>

clone

public org.eclipse.collections.api.map.MutableMap<K,V> clone()

Specified by:

clone in interface org.eclipse.collections.api.map.MutableMap<K,V>

Specified by:

clone in class AbstractMutableMap<K,V>

newEmpty

public <K,V> org.eclipse.collections.api.map.MutableMap<K,V> newEmpty(int capacity)

Description copied from class: AbstractMutableMap

Creates a new instance of the same type, using the given capacity and the default growth parameters.

Specified by:

newEmpty in class AbstractMutableMap<K,V>

notEmpty

public boolean notEmpty()

Specified by:

notEmpty in interface org.eclipse.collections.api.RichIterable<V>

Overrides:

notEmpty in class AbstractRichIterable<V>

forEachWithIndex

public void forEachWithIndex(org.eclipse.collections.api.block.procedure.primitive.ObjectIntProcedure<? super V> objectIntProcedure)

Specified by:

forEachWithIndex in interface org.eclipse.collections.api.InternalIterable<V>

Overrides:

forEachWithIndex in class AbstractMapIterable<K,V>

iterator

public Iterator<V> iterator()

Specified by:

iterator in interface Iterable<V>

Overrides:

iterator in class AbstractMutableMapIterable<K,V>

newEmpty

public org.eclipse.collections.api.map.MutableMap<K,V> newEmpty()

Specified by:

newEmpty in interface org.eclipse.collections.api.map.MutableMap<K,V>

Specified by:

newEmpty in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

forEachValue

public void forEachValue(org.eclipse.collections.api.block.procedure.Procedure<? super V> procedure)

Specified by:

forEachValue in interface org.eclipse.collections.api.map.MapIterable<K,V>

Overrides:

forEachValue in class AbstractMapIterable<K,V>

forEachKey

public void forEachKey(org.eclipse.collections.api.block.procedure.Procedure<? super K> procedure)

Specified by:

forEachKey in interface org.eclipse.collections.api.map.MapIterable<K,V>

Overrides:

forEachKey in class AbstractMapIterable<K,V>

forEachKeyValue

public void forEachKeyValue(org.eclipse.collections.api.block.procedure.Procedure2<? super K,? super V> procedure)

Specified by:

forEachKeyValue in interface org.eclipse.collections.api.map.MapIterable<K,V>

collectKeysAndValues

public <E> org.eclipse.collections.api.map.MutableMap<K,V> collectKeysAndValues(Iterable<E> iterable,
                                                                                org.eclipse.collections.api.block.function.Function<? super E,? extends K> keyFunction,
                                                                                org.eclipse.collections.api.block.function.Function<? super E,? extends V> valueFunction)

Specified by:

collectKeysAndValues in interface org.eclipse.collections.api.map.MutableMap<K,V>

removeKey

public V removeKey(K key)

Specified by:

removeKey in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

getIfAbsentPutWith

public <P> V getIfAbsentPutWith(K key,
                                org.eclipse.collections.api.block.function.Function<? super P,? extends V> function,
                                P parameter)

Specified by:

getIfAbsentPutWith in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

getIfAbsentPutWith in class AbstractMutableMapIterable<K,V>

getIfAbsent

public V getIfAbsent(K key,
                     org.eclipse.collections.api.block.function.Function0<? extends V> function)

Specified by:

getIfAbsent in interface org.eclipse.collections.api.map.MapIterable<K,V>

Overrides:

getIfAbsent in class AbstractMapIterable<K,V>

getIfAbsentWith

public <P> V getIfAbsentWith(K key,
                             org.eclipse.collections.api.block.function.Function<? super P,? extends V> function,
                             P parameter)

Specified by:

getIfAbsentWith in interface org.eclipse.collections.api.map.MapIterable<K,V>

Overrides:

getIfAbsentWith in class AbstractMapIterable<K,V>

ifPresentApply

public <A> A ifPresentApply(K key,
                            org.eclipse.collections.api.block.function.Function<? super V,? extends A> function)

Specified by:

ifPresentApply in interface org.eclipse.collections.api.map.MapIterable<K,V>

Overrides:

ifPresentApply in class AbstractMapIterable<K,V>

forEachWith

public <P> void forEachWith(org.eclipse.collections.api.block.procedure.Procedure2<? super V,? super P> procedure,
                            P parameter)

Specified by:

forEachWith in interface org.eclipse.collections.api.InternalIterable<V>

Overrides:

forEachWith in class AbstractMapIterable<K,V>

updateValue

public V updateValue(K key,
                     org.eclipse.collections.api.block.function.Function0<? extends V> factory,
                     org.eclipse.collections.api.block.function.Function<? super V,? extends V> function)

Specified by:

updateValue in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

updateValue in class AbstractMutableMapIterable<K,V>

updateValueWith

public <P> V updateValueWith(K key,
                             org.eclipse.collections.api.block.function.Function0<? extends V> factory,
                             org.eclipse.collections.api.block.function.Function2<? super V,? super P,? extends V> function,
                             P parameter)

Specified by:

updateValueWith in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Overrides:

updateValueWith in class AbstractMutableMapIterable<K,V>

toImmutable

public org.eclipse.collections.api.map.ImmutableMap<K,V> toImmutable()

Specified by:

toImmutable in interface org.eclipse.collections.api.map.MapIterable<K,V>

Specified by:

toImmutable in interface org.eclipse.collections.api.map.MutableMapIterable<K,V>

Specified by:

toImmutable in interface org.eclipse.collections.api.map.UnsortedMapIterable<K,V>

Overrides:

toImmutable in class AbstractMutableMap<K,V>