HashMap

Требования к платформе и версии: Common (1.0)

expect class HashMap<K, V> : MutableMap<K, V> 

Реализация MutableMap на основе хеш-таблицы.

Этот класс хранит пары ключ-значение с помощью структуры данных «хеш-таблица», обеспечивающей быстрый поиск по ключам. Он полностью реализует контракт MutableMap, предоставляя все стандартные операции с отображением, включая добавление, удаление и поиск значений по ключу.

Ключи и значения null

HashMap принимает null в качестве ключа. Поскольку ключи уникальны, в отображении может существовать не более одной записи с ключом null. HashMap также принимает null в качестве значения, и несколько записей могут иметь значения null.

Контракты хеш-кода и равенства ключей

HashMap использует функции Any.hashCode и Any.equals ключей для организации записей и поиска по ним. Ключи считаются равными, если функция Any.equals возвращает true, а равные ключи должны иметь одинаковое значение Any.hashCode. Нарушение этого контракта может привести к неправильному поведению.

Функции Any.hashCode и Any.equals должны быть согласованными и неизменными на протяжении всего времени существования объектов-ключей. Изменение объекта-ключа, влияющее на его хеш-код или равенство после его использования в качестве ключа в HashMap, может привести к тому, что запись станет недоступной.

Характеристики производительности

Приведённые ниже характеристики производительности предполагают, что функция Any.hashCode ключей равномерно распределяет их по хеш-таблице, сводя к минимуму коллизии. Неудачная хеш-функция, вызывающая множество коллизий, может снизить производительность.

HashMap обеспечивает эффективную реализацию распространённых операций:

• Поиск (get, containsKey): время O(1)

• Добавление и удаление (put, remove): время O(1)

• Поиск значения (containsValue): время O(n), требует просмотра всех записей

• Итерация (entries, keys, values): время O(n)

Порядок итерации

HashMap не гарантирует определённый порядок итерации по ключам, значениям или записям. Порядок итерации непредсказуем и может измениться при перехешировании отображения (когда записи добавляются или удаляются и внутренняя ёмкость корректируется). Не полагайтесь на какой-либо определённый порядок итерации.

Если необходим предсказуемый порядок итерации, рассмотрите возможность использования LinkedHashMap, которая сохраняет порядок добавления элементов.

Рекомендации по использованию

HashMap использует внутреннюю структуру данных с конечной ёмкостью — максимальным количеством записей, которое она может хранить до необходимости увеличения. По мере добавления записей отображение отслеживает коэффициент загрузки — отношение количества записей к текущей ёмкости. Когда это отношение превышает определённый порог, отображение автоматически увеличивает ёмкость и выполняет перехеширование — перестраивает внутреннюю структуру данных, чтобы перераспределить записи. Перехеширование — относительно затратная операция, временно снижающая производительность. При создании HashMap можно дополнительно указать начальную ёмкость и порог коэффициента загрузки. Обратите внимание, что эти параметры являются лишь рекомендациями для реализации и могут быть проигнорированы.

Для оптимизации производительности и использования памяти:

• Если количество записей известно заранее, используйте конструктор с начальной ёмкостью, чтобы избежать многократного перехеширования при росте отображения.

• Выбирайте подходящий коэффициент загрузки при создании отображения. Более низкий коэффициент загрузки уменьшает вероятность коллизий, но требует больше памяти, а более высокий экономит память, но может увеличить время поиска. Коэффициент загрузки по умолчанию обычно обеспечивает хороший баланс.

• Убедитесь, что реализации Any.hashCode объектов-ключей обеспечивают хорошее распределение, чтобы свести к минимуму коллизии и сохранить высокую производительность.

• При добавлении нескольких записей предпочитайте putAll нескольким отдельным вызовам put.

Потокобезопасность

HashMap не является потокобезопасной. Если несколько потоков одновременно обращаются к экземпляру и хотя бы один из них изменяет его, требуется внешняя синхронизация.

Параметры типа

Требования к платформе и версии: JS (1.1)

actual open class HashMap<K, V> : AbstractMutableMap<K, V> , MutableMap<K, V> 

Реализация MutableMap на основе хеш-таблицы.

Этот класс хранит пары ключ-значение с помощью структуры данных «хеш-таблица», обеспечивающей быстрый поиск по ключам. Он полностью реализует контракт MutableMap, предоставляя все стандартные операции с отображением, включая добавление, удаление и поиск значений по ключу.

Ключи и значения null

HashMap принимает null в качестве ключа. Поскольку ключи уникальны, в отображении может существовать не более одной записи с ключом null. HashMap также принимает null в качестве значения, и несколько записей могут иметь значения null.

Контракты хеш-кода и равенства ключей

HashMap использует функции Any.hashCode и Any.equals ключей для организации записей и поиска по ним. Ключи считаются равными, если функция Any.equals возвращает true, а равные ключи должны иметь одинаковое значение Any.hashCode. Нарушение этого контракта может привести к неправильному поведению.

Функции Any.hashCode и Any.equals должны быть согласованными и неизменными на протяжении всего времени существования объектов-ключей. Изменение объекта-ключа, влияющее на его хеш-код или равенство после его использования в качестве ключа в HashMap, может привести к тому, что запись станет недоступной.

Характеристики производительности

Приведённые ниже характеристики производительности предполагают, что функция Any.hashCode ключей равномерно распределяет их по хеш-таблице, сводя к минимуму коллизии. Неудачная хеш-функция, вызывающая множество коллизий, может снизить производительность.

HashMap обеспечивает эффективную реализацию распространённых операций:

• Поиск (get, containsKey): время O(1)

• Добавление и удаление (put, remove): время O(1)

• Поиск значения (containsValue): время O(n), требует просмотра всех записей

• Итерация (entries, keys, values): время O(n)

Порядок итерации

HashMap не гарантирует определённый порядок итерации по ключам, значениям или записям. Порядок итерации непредсказуем и может измениться при перехешировании отображения (когда записи добавляются или удаляются и внутренняя ёмкость корректируется). Не полагайтесь на какой-либо определённый порядок итерации.

Если необходим предсказуемый порядок итерации, рассмотрите возможность использования LinkedHashMap, которая сохраняет порядок добавления элементов.

Рекомендации по использованию

HashMap использует внутреннюю структуру данных с конечной ёмкостью — максимальным количеством записей, которое она может хранить до необходимости увеличения. Когда отображение заполняется, оно автоматически увеличивает ёмкость и выполняет перехеширование — перестраивает внутреннюю структуру данных, чтобы перераспределить записи. Перехеширование — относительно затратная операция, временно снижающая производительность. При создании HashMap можно дополнительно указать начальную ёмкость, которая будет использоваться для определения размера внутренней структуры данных и потенциально поможет избежать перехеширования при росте отображения.

Для оптимизации производительности и использования памяти:

• Если количество записей известно заранее, используйте конструктор с начальной ёмкостью, чтобы избежать многократного перехеширования при росте отображения.

• Убедитесь, что реализации Any.hashCode объектов-ключей обеспечивают хорошее распределение, чтобы свести к минимуму коллизии и сохранить высокую производительность.

• При добавлении нескольких записей предпочитайте putAll нескольким отдельным вызовам put.

Потокобезопасность

HashMap не является потокобезопасной. Если несколько потоков одновременно обращаются к экземпляру и хотя бы один из них изменяет его, требуется внешняя синхронизация.

Параметры типа

Наследники

Требования к платформе и версии: JVM (1.1)

actual typealias HashMap<K, V> = java.util.HashMap<K, V>

Реализация MutableMap на основе хеш-таблицы.

Этот класс хранит пары ключ-значение с помощью структуры данных «хеш-таблица», обеспечивающей быстрый поиск по ключам. Он полностью реализует контракт MutableMap, предоставляя все стандартные операции с отображением, включая добавление, удаление и поиск значений по ключу.

Ключи и значения null

HashMap принимает null в качестве ключа. Поскольку ключи уникальны, в отображении может существовать не более одной записи с ключом null. HashMap также принимает null в качестве значения, и несколько записей могут иметь значения null.

Контракты хеш-кода и равенства ключей

HashMap использует функции Any.hashCode и Any.equals ключей для организации записей и поиска по ним. Ключи считаются равными, если функция Any.equals возвращает true, а равные ключи должны иметь одинаковое значение Any.hashCode. Нарушение этого контракта может привести к неправильному поведению.

Функции Any.hashCode и Any.equals должны быть согласованными и неизменными на протяжении всего времени существования объектов-ключей. Изменение объекта-ключа, влияющее на его хеш-код или равенство после его использования в качестве ключа в HashMap, может привести к тому, что запись станет недоступной.

Характеристики производительности

Приведённые ниже характеристики производительности предполагают, что функция Any.hashCode ключей равномерно распределяет их по хеш-таблице, сводя к минимуму коллизии. Неудачная хеш-функция, вызывающая множество коллизий, может снизить производительность.

HashMap обеспечивает эффективную реализацию распространённых операций:

• Поиск (get, containsKey): время O(1)

• Добавление и удаление (put, remove): время O(1)

• Поиск значения (containsValue): время O(n), требует просмотра всех записей

• Итерация (entries, keys, values): время O(n)

Порядок итерации

HashMap не гарантирует определённый порядок итерации по ключам, значениям или записям. Порядок итерации непредсказуем и может измениться при перехешировании отображения (когда записи добавляются или удаляются и внутренняя ёмкость корректируется). Не полагайтесь на какой-либо определённый порядок итерации.

Если необходим предсказуемый порядок итерации, рассмотрите возможность использования LinkedHashMap, которая сохраняет порядок добавления элементов.

Рекомендации по использованию

HashMap использует внутреннюю структуру данных с конечной ёмкостью — максимальным количеством записей, которое она может хранить до необходимости увеличения. По мере добавления записей отображение отслеживает коэффициент загрузки — отношение количества записей к текущей ёмкости. Когда это отношение превышает определённый порог, отображение автоматически увеличивает ёмкость и выполняет перехеширование — перестраивает внутреннюю структуру данных, чтобы перераспределить записи. Перехеширование — относительно затратная операция, временно снижающая производительность. При создании HashMap можно дополнительно указать начальную ёмкость и порог коэффициента загрузки.

Для оптимизации производительности и использования памяти:

• Если количество записей известно заранее, используйте конструктор с начальной ёмкостью, чтобы избежать многократного перехеширования при росте отображения.

• Выбирайте подходящий коэффициент загрузки при создании отображения. Более низкий коэффициент загрузки уменьшает вероятность коллизий, но требует больше памяти, а более высокий экономит память, но может увеличить время поиска. Коэффициент загрузки по умолчанию обычно обеспечивает хороший баланс.

• Убедитесь, что реализации Any.hashCode объектов-ключей обеспечивают хорошее распределение, чтобы свести к минимуму коллизии и сохранить высокую производительность.

• При добавлении нескольких записей предпочитайте putAll нескольким отдельным вызовам put.

Потокобезопасность

HashMap не является потокобезопасной. Если несколько потоков одновременно обращаются к экземпляру и хотя бы один из них изменяет его, требуется внешняя синхронизация.

Параметры типа

Требования к платформе и версии: Native (1.3), Wasm-JS (1.8), Wasm-WASI (1.8)

actual class HashMap<K, V> : MutableMap<K, V> 

Реализация MutableMap на основе хеш-таблицы.

Этот класс хранит пары ключ-значение с помощью структуры данных «хеш-таблица», обеспечивающей быстрый поиск по ключам. Он полностью реализует контракт MutableMap, предоставляя все стандартные операции с отображением, включая добавление, удаление и поиск значений по ключу.

Ключи и значения null

HashMap принимает null в качестве ключа. Поскольку ключи уникальны, в отображении может существовать не более одной записи с ключом null. HashMap также принимает null в качестве значения, и несколько записей могут иметь значения null.

Контракты хеш-кода и равенства ключей

HashMap использует функции Any.hashCode и Any.equals ключей для организации записей и поиска по ним. Ключи считаются равными, если функция Any.equals возвращает true, а равные ключи должны иметь одинаковое значение Any.hashCode. Нарушение этого контракта может привести к неправильному поведению.

Функции Any.hashCode и Any.equals должны быть согласованными и неизменными на протяжении всего времени существования объектов-ключей. Изменение объекта-ключа, влияющее на его хеш-код или равенство после его использования в качестве ключа в HashMap, может привести к тому, что запись станет недоступной.

Характеристики производительности

Приведённые ниже характеристики производительности предполагают, что функция Any.hashCode ключей равномерно распределяет их по хеш-таблице, сводя к минимуму коллизии. Неудачная хеш-функция, вызывающая множество коллизий, может снизить производительность.

HashMap обеспечивает эффективную реализацию распространённых операций:

• Поиск (get, containsKey): время O(1)

• Добавление и удаление (put, remove): время O(1)

• Поиск значения (containsValue): время O(n), требует просмотра всех записей

• Итерация (entries, keys, values): время O(n)

Порядок итерации

HashMap не гарантирует определённый порядок итерации по ключам, значениям или записям. Порядок итерации непредсказуем и может измениться при перехешировании отображения (когда записи добавляются или удаляются и внутренняя ёмкость корректируется). Не полагайтесь на какой-либо определённый порядок итерации.

Если необходим предсказуемый порядок итерации, рассмотрите возможность использования LinkedHashMap, которая сохраняет порядок добавления элементов.

Рекомендации по использованию

HashMap использует внутреннюю структуру данных с конечной ёмкостью — максимальным количеством записей, которое она может хранить до необходимости увеличения. Когда отображение заполняется, оно автоматически увеличивает ёмкость и выполняет перехеширование — перестраивает внутреннюю структуру данных, чтобы перераспределить записи. Перехеширование — относительно затратная операция, временно снижающая производительность. При создании HashMap можно дополнительно указать начальную ёмкость, которая будет использоваться для определения размера внутренней структуры данных и потенциально поможет избежать перехеширования при росте отображения.

Для оптимизации производительности и использования памяти:

• Если количество записей известно заранее, используйте конструктор с начальной ёмкостью, чтобы избежать многократного перехеширования при росте отображения.

• Убедитесь, что реализации Any.hashCode объектов-ключей обеспечивают хорошее распределение, чтобы свести к минимуму коллизии и сохранить высокую производительность.

• При добавлении нескольких записей предпочитайте putAll нескольким отдельным вызовам put.

Потокобезопасность

HashMap не является потокобезопасной. Если несколько потоков одновременно обращаются к экземпляру и хотя бы один из них изменяет его, требуется внешняя синхронизация.

Параметры типа

expect constructor()

expect constructor(initialCapacity: Int)

expect constructor(initialCapacity: Int, loadFactor: Float)

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

expect open override val entries: MutableSet<MutableMap.MutableEntry<K, V>>

expect open override val keys: MutableSet<K>

actual open override val keys: MutableSet<K>

expect open override val size: Int

expect open override val values: MutableCollection<V>

actual open override val values: MutableCollection<V>

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

fun <K, V> Map<out K, V>.any(): Boolean

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

inline fun <K, V> Map<out K, V>.asIterable(): Iterable<Map.Entry<K, V>>

@ExperimentalJsExport


@ExperimentalJsCollectionsApi

open fun asJsMapView(): JsMap<K, V>

@ExperimentalJsExport


@ExperimentalJsCollectionsApi

open fun asJsReadonlyMapView(): JsReadonlyMap<K, V>

fun <K, V> Map<out K, V>.asSequence(): Sequence<Map.Entry<K, V>>

expect open override fun clear()

inline operator fun <K, V> Map<out K, V>.contains(key: K): Boolean

expect open override fun containsKey(key: K): Boolean

inline fun <K> Map<out K, *>.containsKey(key: K): Boolean

expect open override fun containsValue(value: V): Boolean

inline fun <K, V> Map<K, V>.containsValue(value: V): Boolean

inline fun <K, V> Map<out K, V>.count(): Int

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

open operator override fun equals(other: Any?): Boolean

open operator override fun equals(other: Any?): Boolean

inline fun <K, V> Map<out K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

inline fun <K, V> Map<out K, V>.filterKeys(predicate: (K) -> Boolean): Map<K, V>

inline fun <K, V> Map<out K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>

@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

@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

inline fun <K, V> Map<out K, V>.filterValues(predicate: (V) -> Boolean): Map<K, V>

inline fun <K, V, R : Any> Map<out K, V>.firstNotNullOf(transform: (Map.Entry<K, V>) -> R?): R

inline fun <K, V, R : Any> Map<out K, V>.firstNotNullOfOrNull(transform: (Map.Entry<K, V>) -> R?): R?

inline fun <K, V, R> Map<out K, V>.flatMap(transform: (Map.Entry<K, V>) -> Iterable<R>): List<R>

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

@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

@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

inline fun <K, V> Map<out K, V>.forEach(action: (Map.Entry<K, V>) -> Unit)

expect open operator override fun get(key: K): V?

inline operator fun <K, V> Map<out K, V>.get(key: K): V?

inline fun <K, V> Map<out K, V>.getOrDefault(key: K, defaultValue: V): V

inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V

@ExperimentalStdlibApi
inline fun <K, V> Map<K, V>.getOrElseIfMissing(key: K, defaultValue: () -> V): V

@ExperimentalStdlibApi
inline fun <K, V> Map<K, V>.getOrElseIfNull(key: K, defaultValue: () -> V): V

inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V

@ExperimentalStdlibApi
inline fun <K, V> MutableMap<K, V>.getOrPutIfMissing(key: K, crossinline defaultValue: () -> V): V

@ExperimentalStdlibApi
inline fun <K, V> MutableMap<K, V>.getOrPutIfNull(key: K, crossinline defaultValue: () -> V): V

fun <K, V> Map<K, V>.getValue(key: K): V

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

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

open override fun hashCode(): Int

open override fun hashCode(): Int

expect open override fun isEmpty(): Boolean

open override fun isEmpty(): Boolean

inline fun <K, V> Map<out K, V>.isNotEmpty(): Boolean

inline fun <K, V> Map<out K, V>?.isNullOrEmpty(): Boolean

inline operator fun <K, V> Map<out K, V>.iterator(): Iterator<Map.Entry<K, V>>

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

inline fun <K, V, R> Map<out K, V>.map(transform: (Map.Entry<K, V>) -> R): List<R>

inline fun <K, V, R> Map<out K, V>.mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>

@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

inline fun <K, V, R : Any> Map<out K, V>.mapNotNull(transform: (Map.Entry<K, V>) -> R?): List<R>

@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

@IgnorableReturnValue
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.mapTo(destination: C, transform: (Map.Entry<K, V>) -> R): C

inline fun <K, V, R> Map<out K, V>.mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>

@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

@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>

inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?

inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxByOrNull(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?

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

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?

inline fun <K, V, R> Map<out K, V>.maxOfWith(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R

inline fun <K, V, R> Map<out K, V>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R?

@JvmName(name = "maxWithOrThrow")
inline fun <K, V> Map<out K, V>.maxWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>

inline fun <K, V> Map<out K, V>.maxWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?

inline fun <K, V> Map<out K, V>.maxWithOrNull(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?

@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>

inline fun <K, V, R : Comparable<R>> Map<out K, V>.minBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?

inline fun <K, V, R : Comparable<R>> Map<out K, V>.minByOrNull(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?

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

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?

inline fun <K, V, R> Map<out K, V>.minOfWith(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R

inline fun <K, V, R> Map<out K, V>.minOfWithOrNull(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R?

operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>

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

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

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

inline operator fun <K, V> MutableMap<K, V>.minusAssign(key: K)

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

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

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

@JvmName(name = "minWithOrThrow")
inline fun <K, V> Map<out K, V>.minWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>

fun <K, V> Map<out K, V>.minWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?

inline fun <K, V> Map<out K, V>.minWithOrNull(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?

fun <K, V> Map<out K, V>.none(): Boolean

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

inline fun <K, V> Map<K, V>?.orEmpty(): Map<K, V>

operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>

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

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

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

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

inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>)

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

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

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

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

@IgnorableReturnValue
expect open override fun put(key: K, value: V): V?

expect open override fun putAll(from: Map<out K, V>)

fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>)

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

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

@IgnorableReturnValue
expect open override fun remove(key: K): V?

@IgnorableReturnValue
inline fun <K, V> MutableMap<out K, V>.remove(key: K): V?

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

inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)

inline operator fun <V> MutableMap<in String, in V>.setValue(thisRef: Any?, property: KProperty<*>, value: V)

fun <K, V> Map<out K, V>.toList(): List<Pair<K, V>>

fun <K, V> Map<out K, V>.toMap(): Map<K, V>

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

fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V>

inline fun Map<String, String>.toProperties(): Properties

fun <K : Comparable<K>, V> Map<out K, V>.toSortedMap(): SortedMap<K, V>

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

open override fun toString(): String

open override fun toString(): String

fun <K, V> Map<K, V>.withDefault(defaultValue: (key: K) -> V): Map<K, V>

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