LinkedHashMap

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

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

Реализация MutableMap на основе хеш-таблицы, сохраняющая порядок вставки.

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

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

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

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

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

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

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

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

LinkedHashMap эффективно выполняет распространенные операции:

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

• Вставка и удаление (put, remove): время O(1)

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

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

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

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

Обратите внимание, что повторная вставка ключа в отображение не влияет на порядок вставки. Ключ k повторно вставляется в отображение, когда вызывается put(k, v), а отображение уже содержит запись с ключом k.

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

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

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

Чтобы оптимизировать производительность и использование памяти:

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

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

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

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

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

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

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

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

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

Реализация MutableMap на основе хеш-таблицы, сохраняющая порядок вставки.

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

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

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

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

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

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

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

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

LinkedHashMap эффективно выполняет распространенные операции:

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

• Вставка и удаление (put, remove): время O(1)

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

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

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

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

Обратите внимание, что повторная вставка ключа в отображение не влияет на порядок вставки. Ключ k повторно вставляется в отображение, когда вызывается put(k, v), а отображение уже содержит запись с ключом k.

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

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

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

Чтобы оптимизировать производительность и использование памяти:

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

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

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

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

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

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

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

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

Реализация MutableMap на основе хеш-таблицы, сохраняющая порядок вставки.

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

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

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

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

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

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

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

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

LinkedHashMap эффективно выполняет распространенные операции:

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

• Вставка и удаление (put, remove): время O(1)

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

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

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

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

Обратите внимание, что повторная вставка ключа в отображение не влияет на порядок вставки. Ключ k повторно вставляется в отображение, когда вызывается put(k, v), а отображение уже содержит запись с ключом k.

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

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

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

Чтобы оптимизировать производительность и использование памяти:

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

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

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

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

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

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

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

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

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

Реализация MutableMap на основе хеш-таблицы, сохраняющая порядок вставки.

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

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

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

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

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

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

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

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

LinkedHashMap эффективно выполняет распространенные операции:

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

• Вставка и удаление (put, remove): время O(1)

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

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

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

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

Обратите внимание, что повторная вставка ключа в отображение не влияет на порядок вставки. Ключ k повторно вставляется в отображение, когда вызывается put(k, v), а отображение уже содержит запись с ключом k.

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

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

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

Чтобы оптимизировать производительность и использование памяти:

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

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

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

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

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

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

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

actual 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

actual 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()

actual 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

actual 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

actual 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

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?

actual 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

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?

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

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

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

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>