kotlin-stdlib/kotlin.collections/LinkedHashMap

LinkedHashMap

expect class LinkedHashMap<K, V> : MutableMap<K, V> (source)

A hash table implementation of MutableMap that maintains insertion order.

This class stores key-value pairs using a hash table data structure that provides fast lookups based on keys, while also maintaining the order in which entries were inserted. It fully implements the MutableMap contract, providing all standard map operations including insertion, removal, and lookup of values by key.

Null keys and values

LinkedHashMap accepts null as a key. Since keys are unique, at most one entry with a null key can exist in the map. LinkedHashMap also accepts null as a value, and multiple entries can have null values.

Key's hash code and equality contracts

LinkedHashMap relies on the Any.hashCode and Any.equals functions of keys to organize and locate entries. Keys are considered equal if their Any.equals function returns true, and keys that are equal must have the same Any.hashCode value. Violating this contract can lead to incorrect behavior.

The Any.hashCode and Any.equals functions should be consistent and immutable during the lifetime of the key objects. Modifying a key object in a way that changes its hash code or equality after it has been used as a key in a LinkedHashMap may lead to the entry becoming unreachable.

Performance characteristics

The performance characteristics below assume that the Any.hashCode function of keys distributes them uniformly across the hash table, minimizing collisions. A poor hash function that causes many collisions can degrade performance.

LinkedHashMap provides efficient implementation for common operations:

Iteration order

LinkedHashMap maintains a predictable iteration order for its keys, values, and entries. Entries are iterated in the order they were inserted into the map, from oldest to newest. This insertion order is preserved even when the map is rehashed (when entries are added or removed and the internal capacity is adjusted).

Note that the insertion order is not affected if a key is re-inserted into the map. A key k is re-inserted into the map when put(k, v) is called and the map already contains an entry with key k.

If predictable iteration order is not required, consider using HashMap, which may have slightly better performance characteristics.

Usage guidelines

LinkedHashMap uses an internal data structure with a finite capacity - the maximum number of entries it can store before needing to grow. As entries are added, the map tracks its load factor, which is the ratio of the number of entries to the current capacity. When this ratio exceeds a certain threshold, the map automatically increases its capacity and performs rehashing - rebuilding the internal data structure to redistribute entries. Rehashing is a relatively expensive operation that temporarily impacts performance. When creating a LinkedHashMap, you can optionally provide values for the initial capacity and load factor threshold. Note that these parameters are just hints for the implementation and can be ignored.

To optimize performance and memory usage:

  • If the number of entries is known in advance, use the constructor with initial capacity to avoid multiple rehashing operations as the map grows.

  • Choose an appropriate load factor when creating the map. A lower load factor reduces collision probability but uses more memory, while a higher load factor saves memory but may increase lookup time. The default load factor typically provides a good balance.

  • Ensure key objects have well-distributed Any.hashCode implementations to minimize collisions and maintain good performance.

  • Prefer putAll over multiple individual put calls when adding multiple entries.

Thread safety

LinkedHashMap is not thread-safe. If multiple threads access an instance concurrently and at least one thread modifies it, external synchronization is required.

Since Kotlin

1.0

Parameters

K

the type of map keys. The map is invariant in its key type.

V

the type of map values. The mutable map is invariant in its value type.

actual open class LinkedHashMap<K, V> : HashMap<K, V> , MutableMap<K, V> (source)

A hash table implementation of MutableMap that maintains insertion order.

This class stores key-value pairs using a hash table data structure that provides fast lookups based on keys, while also maintaining the order in which entries were inserted. It fully implements the MutableMap contract, providing all standard map operations including insertion, removal, and lookup of values by key.

Null keys and values

LinkedHashMap accepts null as a key. Since keys are unique, at most one entry with a null key can exist in the map. LinkedHashMap also accepts null as a value, and multiple entries can have null values.

Key's hash code and equality contracts

LinkedHashMap relies on the Any.hashCode and Any.equals functions of keys to organize and locate entries. Keys are considered equal if their Any.equals function returns true, and keys that are equal must have the same Any.hashCode value. Violating this contract can lead to incorrect behavior.

The Any.hashCode and Any.equals functions should be consistent and immutable during the lifetime of the key objects. Modifying a key object in a way that changes its hash code or equality after it has been used as a key in a LinkedHashMap may lead to the entry becoming unreachable.

Performance characteristics

The performance characteristics below assume that the Any.hashCode function of keys distributes them uniformly across the hash table, minimizing collisions. A poor hash function that causes many collisions can degrade performance.

LinkedHashMap provides efficient implementation for common operations:

Iteration order

LinkedHashMap maintains a predictable iteration order for its keys, values, and entries. Entries are iterated in the order they were inserted into the map, from oldest to newest. This insertion order is preserved even when the map is rehashed (when entries are added or removed and the internal capacity is adjusted).

Note that the insertion order is not affected if a key is re-inserted into the map. A key k is re-inserted into the map when put(k, v) is called and the map already contains an entry with key k.

If predictable iteration order is not required, consider using HashMap, which may have slightly better performance characteristics.

Usage guidelines

LinkedHashMap uses an internal data structure with a finite capacity - the maximum number of entries it can store before needing to grow. When the map becomes full, the map automatically increases its capacity and performs rehashing - rebuilding the internal data structure to redistribute entries. Rehashing is a relatively expensive operation that temporarily impacts performance. When creating a LinkedHashMap, you can optionally provide an initial capacity value, which will be used to size the internal data structure, potentially avoiding rehashing operations as the map grows.

To optimize performance and memory usage:

  • If the number of entries is known in advance, use the constructor with initial capacity to avoid multiple rehashing operations as the map grows.

  • Ensure key objects have well-distributed Any.hashCode implementations to minimize collisions and maintain good performance.

  • Prefer putAll over multiple individual put calls when adding multiple entries.

Thread safety

LinkedHashMap is not thread-safe. If multiple threads access an instance concurrently and at least one thread modifies it, external synchronization is required.

Since Kotlin

1.1

Parameters

K

the type of map keys. The map is invariant in its key type.

V

the type of map values. The mutable map is invariant in its value type.

actual typealias LinkedHashMap<K, V> = java.util.LinkedHashMap<K, V>(source)

A hash table implementation of MutableMap that maintains insertion order.

This class stores key-value pairs using a hash table data structure that provides fast lookups based on keys, while also maintaining the order in which entries were inserted. It fully implements the MutableMap contract, providing all standard map operations including insertion, removal, and lookup of values by key.

Null keys and values

LinkedHashMap accepts null as a key. Since keys are unique, at most one entry with a null key can exist in the map. LinkedHashMap also accepts null as a value, and multiple entries can have null values.

Key's hash code and equality contracts

LinkedHashMap relies on the Any.hashCode and Any.equals functions of keys to organize and locate entries. Keys are considered equal if their Any.equals function returns true, and keys that are equal must have the same Any.hashCode value. Violating this contract can lead to incorrect behavior.

The Any.hashCode and Any.equals functions should be consistent and immutable during the lifetime of the key objects. Modifying a key object in a way that changes its hash code or equality after it has been used as a key in a LinkedHashMap may lead to the entry becoming unreachable.

Performance characteristics

The performance characteristics below assume that the Any.hashCode function of keys distributes them uniformly across the hash table, minimizing collisions. A poor hash function that causes many collisions can degrade performance.

LinkedHashMap provides efficient implementation for common operations:

  • Lookup (get, containsKey): O(1) time

  • Insertion and removal (put, remove): O(1) time

  • Value search (containsValue): O(n) time, requires scanning all entries

  • Iteration (entries, keys, values): O(n) time

Iteration order

LinkedHashMap maintains a predictable iteration order for its keys, values, and entries. Entries are iterated in the order they were inserted into the map, from oldest to newest. This insertion order is preserved even when the map is rehashed (when entries are added or removed and the internal capacity is adjusted).

Note that the insertion order is not affected if a key is re-inserted into the map. A key k is re-inserted into the map when put(k, v) is called and the map already contains an entry with key k.

If predictable iteration order is not required, consider using HashMap, which may have slightly better performance characteristics.

Usage guidelines

LinkedHashMap uses an internal data structure with a finite capacity - the maximum number of entries it can store before needing to grow. As entries are added, the map tracks its load factor, which is the ratio of the number of entries to the current capacity. When this ratio exceeds a certain threshold, the map automatically increases its capacity and performs rehashing - rebuilding the internal data structure to redistribute entries. Rehashing is a relatively expensive operation that temporarily impacts performance. When creating a LinkedHashMap, you can optionally provide values for the initial capacity and load factor threshold. Note that these parameters are just hints for the implementation and can be ignored.

To optimize performance and memory usage:

  • If the number of entries is known in advance, use the constructor with initial capacity to avoid multiple rehashing operations as the map grows.

  • Choose an appropriate load factor when creating the map. A lower load factor reduces collision probability but uses more memory, while a higher load factor saves memory but may increase lookup time. The default load factor typically provides a good balance.

  • Ensure key objects have well-distributed Any.hashCode implementations to minimize collisions and maintain good performance.

  • Prefer putAll over multiple individual put calls when adding multiple entries.

Thread safety

LinkedHashMap is not thread-safe. If multiple threads access an instance concurrently and at least one thread modifies it, external synchronization is required.

Since Kotlin

1.1

Parameters

K

the type of map keys. The map is invariant in its key type.

V

the type of map values. The mutable map is invariant in its value type.

actual typealias LinkedHashMap<K, V> = HashMap<K, V>

A hash table implementation of MutableMap that maintains insertion order.

This class stores key-value pairs using a hash table data structure that provides fast lookups based on keys, while also maintaining the order in which entries were inserted. It fully implements the MutableMap contract, providing all standard map operations including insertion, removal, and lookup of values by key.

Null keys and values

LinkedHashMap accepts null as a key. Since keys are unique, at most one entry with a null key can exist in the map. LinkedHashMap also accepts null as a value, and multiple entries can have null values.

Key's hash code and equality contracts

LinkedHashMap relies on the Any.hashCode and Any.equals functions of keys to organize and locate entries. Keys are considered equal if their Any.equals function returns true, and keys that are equal must have the same Any.hashCode value. Violating this contract can lead to incorrect behavior.

The Any.hashCode and Any.equals functions should be consistent and immutable during the lifetime of the key objects. Modifying a key object in a way that changes its hash code or equality after it has been used as a key in a LinkedHashMap may lead to the entry becoming unreachable.

Performance characteristics

The performance characteristics below assume that the Any.hashCode function of keys distributes them uniformly across the hash table, minimizing collisions. A poor hash function that causes many collisions can degrade performance.

LinkedHashMap provides efficient implementation for common operations:

Iteration order

LinkedHashMap maintains a predictable iteration order for its keys, values, and entries. Entries are iterated in the order they were inserted into the map, from oldest to newest. This insertion order is preserved even when the map is rehashed (when entries are added or removed and the internal capacity is adjusted).

Note that the insertion order is not affected if a key is re-inserted into the map. A key k is re-inserted into the map when put(k, v) is called and the map already contains an entry with key k.

If predictable iteration order is not required, consider using HashMap, which may have slightly better performance characteristics.

Usage guidelines

LinkedHashMap uses an internal data structure with a finite capacity - the maximum number of entries it can store before needing to grow. When the map becomes full, the map automatically increases its capacity and performs rehashing - rebuilding the internal data structure to redistribute entries. Rehashing is a relatively expensive operation that temporarily impacts performance. When creating a LinkedHashMap, you can optionally provide an initial capacity value, which will be used to size the internal data structure, potentially avoiding rehashing operations as the map grows.

To optimize performance and memory usage:

  • If the number of entries is known in advance, use the constructor with initial capacity to avoid multiple rehashing operations as the map grows.

  • Ensure key objects have well-distributed Any.hashCode implementations to minimize collisions and maintain good performance.

  • Prefer putAll over multiple individual put calls when adding multiple entries.

Thread safety

LinkedHashMap is not thread-safe. If multiple threads access an instance concurrently and at least one thread modifies it, external synchronization is required.

Since Kotlin

1.3

Parameters

K

the type of map keys. The map is invariant in its key type.

V

the type of map values. The mutable map is invariant in its value type.

actual typealias LinkedHashMap<K, V> = HashMap<K, V>

A hash table implementation of MutableMap that maintains insertion order.

This class stores key-value pairs using a hash table data structure that provides fast lookups based on keys, while also maintaining the order in which entries were inserted. It fully implements the MutableMap contract, providing all standard map operations including insertion, removal, and lookup of values by key.

Null keys and values

LinkedHashMap accepts null as a key. Since keys are unique, at most one entry with a null key can exist in the map. LinkedHashMap also accepts null as a value, and multiple entries can have null values.

Key's hash code and equality contracts

LinkedHashMap relies on the Any.hashCode and Any.equals functions of keys to organize and locate entries. Keys are considered equal if their Any.equals function returns true, and keys that are equal must have the same Any.hashCode value. Violating this contract can lead to incorrect behavior.

The Any.hashCode and Any.equals functions should be consistent and immutable during the lifetime of the key objects. Modifying a key object in a way that changes its hash code or equality after it has been used as a key in a LinkedHashMap may lead to the entry becoming unreachable.

Performance characteristics

The performance characteristics below assume that the Any.hashCode function of keys distributes them uniformly across the hash table, minimizing collisions. A poor hash function that causes many collisions can degrade performance.

LinkedHashMap provides efficient implementation for common operations:

Iteration order

LinkedHashMap maintains a predictable iteration order for its keys, values, and entries. Entries are iterated in the order they were inserted into the map, from oldest to newest. This insertion order is preserved even when the map is rehashed (when entries are added or removed and the internal capacity is adjusted).

Note that the insertion order is not affected if a key is re-inserted into the map. A key k is re-inserted into the map when put(k, v) is called and the map already contains an entry with key k.

If predictable iteration order is not required, consider using HashMap, which may have slightly better performance characteristics.

Usage guidelines

LinkedHashMap uses an internal data structure with a finite capacity - the maximum number of entries it can store before needing to grow. When the map becomes full, the map automatically increases its capacity and performs rehashing - rebuilding the internal data structure to redistribute entries. Rehashing is a relatively expensive operation that temporarily impacts performance. When creating a LinkedHashMap, you can optionally provide an initial capacity value, which will be used to size the internal data structure, potentially avoiding rehashing operations as the map grows.

To optimize performance and memory usage:

  • If the number of entries is known in advance, use the constructor with initial capacity to avoid multiple rehashing operations as the map grows.

  • Ensure key objects have well-distributed Any.hashCode implementations to minimize collisions and maintain good performance.

  • Prefer putAll over multiple individual put calls when adding multiple entries.

Thread safety

LinkedHashMap is not thread-safe. If multiple threads access an instance concurrently and at least one thread modifies it, external synchronization is required.

Since Kotlin

1.8

Parameters

K

the type of map keys. The map is invariant in its key type.

V

the type of map values. The mutable map is invariant in its value type.

actual typealias LinkedHashMap<K, V> = HashMap<K, V>

A hash table implementation of MutableMap that maintains insertion order.

This class stores key-value pairs using a hash table data structure that provides fast lookups based on keys, while also maintaining the order in which entries were inserted. It fully implements the MutableMap contract, providing all standard map operations including insertion, removal, and lookup of values by key.

Null keys and values

LinkedHashMap accepts null as a key. Since keys are unique, at most one entry with a null key can exist in the map. LinkedHashMap also accepts null as a value, and multiple entries can have null values.

Key's hash code and equality contracts

LinkedHashMap relies on the Any.hashCode and Any.equals functions of keys to organize and locate entries. Keys are considered equal if their Any.equals function returns true, and keys that are equal must have the same Any.hashCode value. Violating this contract can lead to incorrect behavior.

The Any.hashCode and Any.equals functions should be consistent and immutable during the lifetime of the key objects. Modifying a key object in a way that changes its hash code or equality after it has been used as a key in a LinkedHashMap may lead to the entry becoming unreachable.

Performance characteristics

The performance characteristics below assume that the Any.hashCode function of keys distributes them uniformly across the hash table, minimizing collisions. A poor hash function that causes many collisions can degrade performance.

LinkedHashMap provides efficient implementation for common operations:

Iteration order

LinkedHashMap maintains a predictable iteration order for its keys, values, and entries. Entries are iterated in the order they were inserted into the map, from oldest to newest. This insertion order is preserved even when the map is rehashed (when entries are added or removed and the internal capacity is adjusted).

Note that the insertion order is not affected if a key is re-inserted into the map. A key k is re-inserted into the map when put(k, v) is called and the map already contains an entry with key k.

If predictable iteration order is not required, consider using HashMap, which may have slightly better performance characteristics.

Usage guidelines

LinkedHashMap uses an internal data structure with a finite capacity - the maximum number of entries it can store before needing to grow. When the map becomes full, the map automatically increases its capacity and performs rehashing - rebuilding the internal data structure to redistribute entries. Rehashing is a relatively expensive operation that temporarily impacts performance. When creating a LinkedHashMap, you can optionally provide an initial capacity value, which will be used to size the internal data structure, potentially avoiding rehashing operations as the map grows.

To optimize performance and memory usage:

  • If the number of entries is known in advance, use the constructor with initial capacity to avoid multiple rehashing operations as the map grows.

  • Ensure key objects have well-distributed Any.hashCode implementations to minimize collisions and maintain good performance.

  • Prefer putAll over multiple individual put calls when adding multiple entries.

Thread safety

LinkedHashMap is not thread-safe. If multiple threads access an instance concurrently and at least one thread modifies it, external synchronization is required.

Since Kotlin

1.8

Parameters

K

the type of map keys. The map is invariant in its key type.

V

the type of map values. The mutable map is invariant in its value type.

Constructors

Link copied to clipboard
expect constructor()

Creates a new empty LinkedHashMap.

expect constructor(initialCapacity: Int)

Creates a new empty LinkedHashMap with the specified initial capacity.

expect constructor(initialCapacity: Int, loadFactor: Float)

Creates a new empty LinkedHashMap with the specified initial capacity and load factor.

expect constructor(original: Map<out K, V>)

Creates a new LinkedHashMap filled with the contents of the specified original map.

actual constructor()

Creates a new empty LinkedHashMap.

actual constructor(initialCapacity: Int)

Creates a new empty LinkedHashMap with the specified initial capacity.

actual constructor(initialCapacity: Int, loadFactor: Float)

Creates a new empty LinkedHashMap with the specified initial capacity and load factor.

actual constructor(original: Map<out K, V>)

Creates a new LinkedHashMap filled with the contents of the specified original map.

Properties

Link copied to clipboard
expect open override val entries: MutableSet<MutableMap.MutableEntry<K, V>>

Returns a MutableSet of all key/value pairs in this map.

Since Kotlin 1.0
actual open override val entries: MutableSet<MutableMap.MutableEntry<K, V>>

Returns a MutableSet of all key/value pairs in this map.

Since Kotlin 1.1
Link copied to clipboard
expect open override val keys: MutableSet<K>

Returns a MutableSet of all keys in this map.

Since Kotlin 1.0
actual open override val keys: MutableSet<K>

Returns a read-only Set of all keys in this map.

Since Kotlin 1.1
Link copied to clipboard
expect open override val size: Int

Returns the number of key/value pairs in the map.

Since Kotlin 1.0
actual open override val size: Int

Returns the number of key/value pairs in the map.

Since Kotlin 1.1
Link copied to clipboard
expect open override val values: MutableCollection<V>

Returns a MutableCollection of all values in this map. Note that this collection may contain duplicate values.

Since Kotlin 1.0
actual open override val values: MutableCollection<V>

Returns a read-only Collection of all values in this map.

Since Kotlin 1.1

Functions

Link copied to clipboard
inline fun <K, V> Map<out K, V>.all(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

Returns true if all entries match the given predicate.

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> Map<out K, V>.any(): Boolean

Returns true if map has at least one entry.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.any(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

Returns true if at least one entry matches the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.asIterable(): Iterable<Map.Entry<K, V>>

Creates an Iterable instance that wraps the original map returning its entries when being iterated.

Since Kotlin 1.0
Link copied to clipboard
@ExperimentalJsExport
@ExperimentalJsCollectionsApi
open fun asJsMapView(): JsMap<K, V>

Returns a view with the JsMap methods to consume it in JavaScript as a regular Map. Structural changes in the base map are synchronized with the view, and vice versa.

Since Kotlin 2.0
Link copied to clipboard
@ExperimentalJsExport
@ExperimentalJsCollectionsApi
open fun asJsReadonlyMapView(): JsReadonlyMap<K, V>

Returns a view with the JsReadonlyMap methods to consume it in JavaScript as a regular readonly Map. Structural changes in the base map are synchronized with the view.

Since Kotlin 2.0
Link copied to clipboard
fun <K, V> Map<out K, V>.asSequence(): Sequence<Map.Entry<K, V>>

Creates a Sequence instance that wraps the original map returning its entries when being iterated.

Since Kotlin 1.0
Link copied to clipboard
expect open override fun clear()

Removes all elements from this map.

Since Kotlin 1.0
actual open override fun clear()

Removes all elements from this map.

Since Kotlin 1.1
Link copied to clipboard
inline operator fun <K, V> Map<out K, V>.contains(key: K): Boolean

Checks if the map contains the given key.

Since Kotlin 1.0
Link copied to clipboard
expect open override fun containsKey(key: K): Boolean

Returns true if the map contains the specified key.

Since Kotlin 1.0
actual open override fun containsKey(key: K): Boolean

Returns true if the map contains the specified key.

Since Kotlin 1.1
Link copied to clipboard
inline fun <K> Map<out K, *>.containsKey(key: K): Boolean

Returns true if the map contains the specified key.

Since Kotlin 1.0
Link copied to clipboard
expect open override fun containsValue(value: V): Boolean

Returns true if the map maps one or more keys to the specified value.

Since Kotlin 1.0
actual open override fun containsValue(value: V): Boolean

Returns true if the map maps one or more keys to the specified value.

Since Kotlin 1.1
Link copied to clipboard
inline fun <K, V> Map<K, V>.containsValue(value: V): Boolean

Returns true if the map maps one or more keys to the specified value.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.count(): Int

Returns the number of entries in this map.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.count(predicate: (Map.Entry<K, V>) -> Boolean): Int

Returns the number of entries matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
open operator override fun equals(other: Any?): Boolean

Compares this map with other instance with the ordered structural equality.

Since Kotlin 1.1
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

Returns a new map containing all key-value pairs matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filterKeys(predicate: (K) -> Boolean): Map<K, V>

Returns a map containing all key-value pairs with keys matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

Returns a new map containing all key-value pairs not matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
@IgnorableReturnValue
inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

Appends all entries not matching the given predicate into the given destination.

Since Kotlin 1.0
Link copied to clipboard
@IgnorableReturnValue
inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

Appends all entries matching the given predicate into the mutable map given as destination parameter.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filterValues(predicate: (V) -> Boolean): Map<K, V>

Returns a map containing all key-value pairs with values matching the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R : Any> Map<out K, V>.firstNotNullOf(transform: (Map.Entry<K, V>) -> R?): R

Returns the first non-null value produced by transform function being applied to entries of this map in iteration order, or throws NoSuchElementException if no non-null value was produced.

Since Kotlin 1.5
Link copied to clipboard
inline fun <K, V, R : Any> Map<out K, V>.firstNotNullOfOrNull(transform: (Map.Entry<K, V>) -> R?): R?

Returns the first non-null value produced by transform function being applied to entries of this map in iteration order, or null if no non-null value was produced.

Since Kotlin 1.5
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.flatMap(transform: (Map.Entry<K, V>) -> Iterable<R>): List<R>

Returns a single list of all elements yielded from results of transform function being invoked on each entry of original map.

Since Kotlin 1.0
@JvmName(name = "flatMapSequence")
inline fun <K, V, R> Map<out K, V>.flatMap(transform: (Map.Entry<K, V>) -> Sequence<R>): List<R>

Returns a single list of all elements yielded from results of transform function being invoked on each entry of original map.

Since Kotlin 1.4
Link copied to clipboard
@IgnorableReturnValue
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Iterable<R>): C

Appends all elements yielded from results of transform function being invoked on each entry of original map, to the given destination.

Since Kotlin 1.0
@JvmName(name = "flatMapSequenceTo")
@IgnorableReturnValue
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Sequence<R>): C

Appends all elements yielded from results of transform function being invoked on each entry of original map, to the given destination.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V> Map<out K, V>.forEach(action: (Map.Entry<K, V>) -> Unit)

Performs the given action on each entry.

Since Kotlin 1.0
Link copied to clipboard
expect open operator override fun get(key: K): V?

Returns the value corresponding to the given key, or null if such a key is not present in the map.

Since Kotlin 1.0
actual open operator override fun get(key: K): V?

Returns the value corresponding to the given key, or null if such a key is not present in the map.

Since Kotlin 1.1
Link copied to clipboard
inline operator fun <K, V> Map<out K, V>.get(key: K): V?

Returns the value corresponding to the given key, or null if such a key is not present in the map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.getOrDefault(key: K, defaultValue: V): V

Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.

Since Kotlin 1.2
Link copied to clipboard
inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V

Returns the value for the given key if the value is present and not null. Otherwise, returns the result of the defaultValue function.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V

Returns the value for the given key if the value is present and not null. Otherwise, calls the defaultValue function, puts its result into the map under the given key and returns the call result.

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> Map<K, V>.getValue(key: K): V

Returns the value for the given key or throws an exception if there is no such key in the map.

Since Kotlin 1.1
inline operator fun <V, V1 : V> Map<in String, V>.getValue(thisRef: Any?, property: KProperty<*>): V1

Returns the value of the property for the given object from this read-only map.

Since Kotlin 1.0
@JvmName(name = "getVar")
inline operator fun <V, V1 : V> MutableMap<in String, out V>.getValue(thisRef: Any?, property: KProperty<*>): V1

Returns the value of the property for the given object from this mutable map.

Since Kotlin 1.0
Link copied to clipboard
open override fun hashCode(): Int

Returns the hash code value for this map.

Since Kotlin 1.1
Link copied to clipboard
expect open override fun isEmpty(): Boolean

Returns true if the map is empty (contains no elements), false otherwise.

Since Kotlin 1.0
open override fun isEmpty(): Boolean

Returns true if the map is empty (contains no elements), false otherwise.

Since Kotlin 1.1
Link copied to clipboard
inline fun <K, V> Map<out K, V>.isNotEmpty(): Boolean

Returns true if this map is not empty.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>?.isNullOrEmpty(): Boolean

Returns true if this nullable map is either null or empty.

Since Kotlin 1.3
Link copied to clipboard
inline operator fun <K, V> Map<out K, V>.iterator(): Iterator<Map.Entry<K, V>>

Returns an Iterator over the entries in the Map.

Since Kotlin 1.0
@JvmName(name = "mutableIterator")
inline operator fun <K, V> MutableMap<K, V>.iterator(): MutableIterator<MutableMap.MutableEntry<K, V>>

Returns a MutableIterator over the mutable entries in the MutableMap.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.map(transform: (Map.Entry<K, V>) -> R): List<R>

Returns a list containing the results of applying the given transform function to each entry in the original map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>

Returns a new Map with entries having the keys obtained by applying the transform function to each entry in this Map and the values of this map.

Since Kotlin 1.0
Link copied to clipboard
@IgnorableReturnValue
inline fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

Populates the given destination map with entries having the keys obtained by applying the transform function to each entry in this Map and the values of this map.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R : Any> Map<out K, V>.mapNotNull(transform: (Map.Entry<K, V>) -> R?): List<R>

Returns a list containing only the non-null results of applying the given transform function to each entry in the original map.

Since Kotlin 1.0
Link copied to clipboard
@IgnorableReturnValue
inline fun <K, V, R : Any, C : MutableCollection<in R>> Map<out K, V>.mapNotNullTo(destination: C, transform: (Map.Entry<K, V>) -> R?): C

Applies the given transform function to each entry in the original map and appends only the non-null results to the given destination.

Since Kotlin 1.0
Link copied to clipboard
@IgnorableReturnValue
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.mapTo(destination: C, transform: (Map.Entry<K, V>) -> R): C

Applies the given transform function to each entry of the original map and appends the results to the given destination.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>

Returns a new map with entries having the keys of this map and the values obtained by applying the transform function to each entry in this Map.

Since Kotlin 1.0
Link copied to clipboard
@IgnorableReturnValue
inline fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

Populates the given destination map with entries having the keys of this map and the values obtained by applying the transform function to each entry in this Map.

Since Kotlin 1.0
Link copied to clipboard
@JvmName(name = "maxByOrThrow")
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>

Returns the first entry yielding the largest value of the given selector function.

Since Kotlin 1.7
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?
Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxByOrNull(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?

Returns the first entry yielding the largest value of the given selector function or null if there are no entries.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> R): R
inline fun <K, V> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> Double): Double
inline fun <K, V> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> Float): Float

Returns the largest value among all values produced by selector function applied to each entry in the map.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> R): R?
inline fun <K, V> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> Double): Double?
inline fun <K, V> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> Float): Float?

Returns the largest value among all values produced by selector function applied to each entry in the map or null if the map is empty.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.maxOfWith(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R

Returns the largest value according to the provided comparator among all values produced by selector function applied to each entry in the map.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R?

Returns the largest value according to the provided comparator among all values produced by selector function applied to each entry in the map or null if the map is empty.

Since Kotlin 1.4
Link copied to clipboard
@JvmName(name = "maxWithOrThrow")
inline fun <K, V> Map<out K, V>.maxWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>

Returns the first entry having the largest value according to the provided comparator.

Since Kotlin 1.7
inline fun <K, V> Map<out K, V>.maxWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?
Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.maxWithOrNull(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?

Returns the first entry having the largest value according to the provided comparator or null if there are no entries.

Since Kotlin 1.4
Link copied to clipboard
@JvmName(name = "minByOrThrow")
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>

Returns the first entry yielding the smallest value of the given selector function.

Since Kotlin 1.7
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?
Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minByOrNull(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?

Returns the first entry yielding the smallest value of the given selector function or null if there are no entries.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> R): R
inline fun <K, V> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> Double): Double
inline fun <K, V> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> Float): Float

Returns the smallest value among all values produced by selector function applied to each entry in the map.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> R): R?
inline fun <K, V> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> Double): Double?
inline fun <K, V> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> Float): Float?

Returns the smallest value among all values produced by selector function applied to each entry in the map or null if the map is empty.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.minOfWith(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R

Returns the smallest value according to the provided comparator among all values produced by selector function applied to each entry in the map.

Since Kotlin 1.4
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.minOfWithOrNull(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R?

Returns the smallest value according to the provided comparator among all values produced by selector function applied to each entry in the map or null if the map is empty.

Since Kotlin 1.4
Link copied to clipboard
operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>

Returns a map containing all entries of the original map except the entry with the given key.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Array<out K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys array.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Iterable<K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys collection.

Since Kotlin 1.1
operator fun <K, V> Map<out K, V>.minus(keys: Sequence<K>): Map<K, V>

Returns a map containing all entries of the original map except those entries the keys of which are contained in the given keys sequence.

Since Kotlin 1.1
Link copied to clipboard
inline operator fun <K, V> MutableMap<K, V>.minusAssign(key: K)

Removes the entry with the given key from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<out K>)

Removes all entries the keys of which are contained in the given keys array from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>)

Removes all entries the keys of which are contained in the given keys collection from this mutable map.

Since Kotlin 1.1
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>)

Removes all entries from the keys of which are contained in the given keys sequence from this mutable map.

Since Kotlin 1.1
Link copied to clipboard
@JvmName(name = "minWithOrThrow")
inline fun <K, V> Map<out K, V>.minWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>

Returns the first entry having the smallest value according to the provided comparator.

Since Kotlin 1.7
fun <K, V> Map<out K, V>.minWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?
Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<out K, V>.minWithOrNull(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?

Returns the first entry having the smallest value according to the provided comparator or null if there are no entries.

Since Kotlin 1.4
Link copied to clipboard
fun <K, V> Map<out K, V>.none(): Boolean

Returns true if the map has no entries.

Since Kotlin 1.0
inline fun <K, V> Map<out K, V>.none(predicate: (Map.Entry<K, V>) -> Boolean): Boolean

Returns true if no entries match the given predicate.

Since Kotlin 1.0
Link copied to clipboard
inline fun <K, V> Map<K, V>?.orEmpty(): Map<K, V>

Returns the Map if its not null, or the empty Map otherwise.

Since Kotlin 1.0
Link copied to clipboard
operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given array of key-value pairs.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(pair: Pair<K, V>): Map<K, V>

Creates a new read-only map by replacing or adding an entry to this map from a given key-value pair.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given collection of key-value pairs.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(map: Map<out K, V>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from another map.

Since Kotlin 1.0
operator fun <K, V> Map<out K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V>

Creates a new read-only map by replacing or adding entries to this map from a given sequence of key-value pairs.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>)

Appends or replaces all pairs from the given array of pairs in this mutable map.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>)

Appends or replaces the given pair in this mutable map.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>)

Appends or replaces all pairs from the given collection of pairs in this mutable map.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>)

Appends or replaces all entries from the given map in this mutable map.

Since Kotlin 1.0
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>)

Appends or replaces all pairs from the given sequence of pairs in this mutable map.

Since Kotlin 1.0
Link copied to clipboard
@IgnorableReturnValue
expect open override fun put(key: K, value: V): V?

Associates the specified value with the specified key in the map.

Since Kotlin 1.0
@IgnorableReturnValue
actual open override fun put(key: K, value: V): V?

Associates the specified value with the specified key in the map.

Since Kotlin 1.1
Link copied to clipboard
expect open override fun putAll(from: Map<out K, V>)

Updates this map with key/value pairs from the specified map from.

Since Kotlin 1.0
actual open override fun putAll(from: Map<out K, V>)

Updates this map with key/value pairs from the specified map from.

Since Kotlin 1.1
Link copied to clipboard
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>)

Puts all the given pairs into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.0
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Iterable<Pair<K, V>>)

Puts all the elements of the given collection into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.0
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Sequence<Pair<K, V>>)

Puts all the elements of the given sequence into this MutableMap with the first component in the pair being the key and the second the value.

Since Kotlin 1.0
Link copied to clipboard
@IgnorableReturnValue
expect open override fun remove(key: K): V?

Removes the specified key and its corresponding value from this map.

Since Kotlin 1.0
@IgnorableReturnValue
actual open override fun remove(key: K): V?

Removes the specified key and its corresponding value from this map.

Since Kotlin 1.1
Link copied to clipboard
@IgnorableReturnValue
inline fun <K, V> MutableMap<out K, V>.remove(key: K): V?

Removes the specified key and its corresponding value from this map.

Since Kotlin 1.0
@IgnorableReturnValue
inline fun <K, V> MutableMap<out K, out V>.remove(key: K, value: V): Boolean

Removes the entry for the specified key only if it is currently mapped to the specified value.

Since Kotlin 1.2
Link copied to clipboard
inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)

Allows to use the index operator for storing values in a mutable map.

Since Kotlin 1.0
Link copied to clipboard
inline operator fun <V> MutableMap<in String, in V>.setValue(thisRef: Any?, property: KProperty<*>, value: V)

Stores the value of the property for the given object in this mutable map.

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> Map<out K, V>.toList(): List<Pair<K, V>>

Returns a List containing all key-value pairs.

Since Kotlin 1.0
Link copied to clipboard
fun <K, V> Map<out K, V>.toMap(): Map<K, V>

Returns a new read-only map containing all key-value pairs from the original map.

Since Kotlin 1.1
@IgnorableReturnValue
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.toMap(destination: M): M

Populates and returns the destination mutable map with key-value pairs from the given map.

Since Kotlin 1.1
Link copied to clipboard
fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V>

Returns a new mutable map containing all key-value pairs from the original map.

Since Kotlin 1.1
Link copied to clipboard
inline fun Map<String, String>.toProperties(): Properties

Converts this Map to a Properties object.

Since Kotlin 1.0
Link copied to clipboard
fun <K : Comparable<K>, V> Map<out K, V>.toSortedMap(): SortedMap<K, V>

Converts this Map to a SortedMap. The resulting SortedMap determines the equality and order of keys according to their natural sorting order.

Since Kotlin 1.0
fun <K, V> Map<out K, V>.toSortedMap(comparator: Comparator<in K>): SortedMap<K, V>

Converts this Map to a SortedMap. The resulting SortedMap determines the equality and order of keys according to the sorting order provided by the given comparator.

Since Kotlin 1.0
Link copied to clipboard
open override fun toString(): String

Returns a string representation of the object.

Since Kotlin 1.1
Link copied to clipboard
fun <K, V> Map<K, V>.withDefault(defaultValue: (key: K) -> V): Map<K, V>

Returns a wrapper of this read-only map, having the implicit default value provided with the specified function defaultValue.

Since Kotlin 1.0
@JvmName(name = "withDefaultMutable")
fun <K, V> MutableMap<K, V>.withDefault(defaultValue: (key: K) -> V): MutableMap<K, V>

Returns a wrapper of this mutable map, having the implicit default value provided with the specified function defaultValue.

Since Kotlin 1.0