sdk/com.m8test.script.core.api.wrapper/MapWrapper

MapWrapper

interface MapWrapper<K, V> : ObjectWrapper<Map<K, V>>

Map 包装接口, 用于增强 Map 功能.

Author

M8Test, [email protected], https://m8test.com

Inheritors

MutableMapWrapper

Functions

all

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

如果所有元素都匹配给定的谓词，则返回 true。

also

abstract fun also(block: (Map<K, V>) -> Unit): ObjectWrapper<Map<K, V>>

对 ObjectWrapper 调用给定的 block 函数，并返回 ObjectWrapper 本身。

any

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

如果至少有一个元素匹配给定的谓词，则返回 true。

apply

abstract fun apply(block: Map<K, V>.() -> Unit): ObjectWrapper<Map<K, V>>

对 ObjectWrapper 调用给定的 block 函数，并返回 ObjectWrapper 本身。

asIterable

abstract fun asIterable(): IterableWrapper<Map.Entry<K, V>>

将此包装器转换为 IterableWrapper。

asSequence

abstract fun asSequence(): SequenceWrapper<Map.Entry<K, V>>

将此包装器转换为 SequenceWrapper。

contains

abstract fun contains(key: K): Boolean

如果此 MapWrapper 包含指定键的映射关系，则返回 true。

containsValue

abstract fun containsValue(value: V): Boolean

如果此 MapWrapper 包含指定的值，则返回 true。

count

abstract fun count(): Int

返回此包装器中的元素数。

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

返回匹配给定谓词的元素数。

filter

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

返回一个新的 MapWrapper，其中包含与此 MapWrapper 中匹配给定谓词的所有元素。

filterKeys

abstract fun filterKeys(predicate: (K) -> Boolean): MapWrapper<K, V>

返回一个新的 MapWrapper，其中包含与此 MapWrapper 中键匹配给定谓词的所有元素。

filterNot

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

返回一个新的 MapWrapper，其中包含与此 MapWrapper 中不匹配给定谓词的所有元素。

filterNotTo

abstract fun <M : MutableMapWrapper<in K, in V>> filterNotTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

将与此 MapWrapper 中不匹配给定谓词的所有元素添加到目标可变 MapWrapper 中。

filterTo

abstract fun <M : MutableMapWrapper<in K, in V>> filterTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M

将与此 MapWrapper 中匹配给定谓词的所有元素添加到目标可变 MapWrapper 中。

filterValues

abstract fun filterValues(predicate: (V) -> Boolean): MapWrapper<K, V>

返回一个新的 MapWrapper，其中包含与此 MapWrapper 中值匹配给定谓词的所有元素。

firstNotNullOf

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

返回由给定转换函数产生的第一个非空元素。

firstNotNullOfOrNull

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

返回由给定转换函数产生的第一个非空元素，如果所有元素均为空，则返回 null。

flatMap

abstract fun <R> flatMap(transform: (Map.Entry<K, V>) -> Iterable<R>): ListWrapper<R>

返回一个列表，其中包含将给定转换函数应用于每个元素的结果。

flatMapTo

abstract fun <R, C : MutableCollectionWrapper<in R>> flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Iterable<R>): C

将给定转换函数应用于每个元素的结果累积到给定的目标集合中。

forEach

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

对每个元素执行给定的操作。

get

abstract fun get(key: K): V?

返回与此 MapWrapper 中指定键关联的值，如果此 MapWrapper 不包含键的映射关系，则返回 null。

getOrElse

abstract fun getOrElse(key: K, defaultValue: () -> V): V

返回指定键映射到的值，如果此 MapWrapper 不包含键的映射关系，则返回由 defaultValue 函数提供的值。

getOrigin

abstract override fun getOrigin(): Map<K, V>

获取被包装的对象.

getValue

abstract fun getValue(key: K): V

返回指定键映射到的值。

isNotEmpty

abstract fun isNotEmpty(): Boolean

如果此 MapWrapper 不为空，则返回 true。

isNullOrEmpty

abstract fun isNullOrEmpty(): Boolean

如果此 MapWrapper 为 null 或为空，则返回 true。

iterator

abstract fun iterator(): Iterator<Map.Entry<K, V>>

返回此 MapWrapper 条目的迭代器。

let

abstract fun <R> let(block: (Map<K, V>) -> R): ObjectWrapper<R>?

对 ObjectWrapper 调用给定的 block 函数，并返回 block 函数的结果包装在 ObjectWrapper 中。

map

abstract fun <R> map(transform: (Map.Entry<K, V>) -> R): ListWrapper<R>

返回一个列表，其中包含将给定转换函数应用于每个元素的结果。

mapKeys

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

返回一个新的 MapWrapper，其中包含将给定转换函数应用于原始 MapWrapper 的每个条目的键的结果。

mapKeysTo

abstract fun <R, M : MutableMapWrapper<in R, in V>> mapKeysTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

将给定转换函数应用于原始 MapWrapper 的每个条目的键的结果累积到给定的目标可变 MapWrapper 中。

mapNotNull

abstract fun <R : Any> mapNotNull(transform: (Map.Entry<K, V>) -> R?): ListWrapper<R>

返回一个列表，其中包含将给定转换函数应用于每个元素的结果，并过滤掉所有空元素。

mapNotNullTo

abstract fun <R : Any, C : MutableCollectionWrapper<in R>> mapNotNullTo(destination: C, transform: (Map.Entry<K, V>) -> R?): C

将给定转换函数应用于每个元素的结果累积到给定的目标集合中，并过滤掉所有空元素。

mapTo

abstract fun <R, C : MutableCollectionWrapper<in R>> mapTo(destination: C, transform: (Map.Entry<K, V>) -> R): C

将给定转换函数应用于每个元素的结果累积到给定的目标集合中。

mapValues

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

返回一个新的 MapWrapper，其中包含将给定转换函数应用于原始 MapWrapper 的每个条目的值的结果。

mapValuesTo

abstract fun <R, M : MutableMapWrapper<in K, in R>> mapValuesTo(destination: M, transform: (Map.Entry<K, V>) -> R): M

将给定转换函数应用于原始 MapWrapper 的每个条目的值的结果累积到给定的目标可变 MapWrapper 中。

maxByOrNull

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

返回按给定选择器函数选择的最大元素。

maxOf

abstract fun <R : Comparable<R>> maxOf(selector: (Map.Entry<K, V>) -> R): R

返回按给定选择器函数选择的最大元素的值。

maxOfOrNull

abstract fun <R : Comparable<R>> maxOfOrNull(selector: (Map.Entry<K, V>) -> R): R?

返回按给定选择器函数选择的最大元素的值，如果集合为空，则返回 null。

maxOfWith

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

返回按给定比较器和选择器函数选择的最大元素的值。

maxOfWithOrNull

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

返回按给定比较器和选择器函数选择的最大元素的值，如果集合为空，则返回 null。

maxWith

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

返回按给定比较器选择的最大元素。

maxWithOrNull

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

返回按给定比较器选择的最大元素，如果集合为空，则返回 null。

minByOrNull

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

返回按给定选择器函数选择的最小元素，如果集合为空，则返回 null。

minOf

abstract fun <R : Comparable<R>> minOf(selector: (Map.Entry<K, V>) -> R): R

返回按给定选择器函数选择的最小元素的值。

minOfOrNull

abstract fun <R : Comparable<R>> minOfOrNull(selector: (Map.Entry<K, V>) -> R): R?

返回按给定选择器函数选择的最小元素的值，如果集合为空，则返回 null。

minOfWith

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

返回按给定比较器和选择器函数选择的最小元素的值。

minOfWithOrNull

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

返回按给定比较器和选择器函数选择的最小元素的值，如果集合为空，则返回 null。

minus

abstract fun minus(keys: Iterable<K>): MapWrapper<K, V>

从此 map 中移除指定 key 对应的 entry，并返回一个新的 MapWrapper。

minWith

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

返回按给定比较器选择的最小元素。

minWithOrNull

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

返回按给定比较器选择的最小元素，如果集合为空，则返回 null。

none

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

如果没有任何元素与给定谓词匹配，则返回 true。

onEach

abstract fun onEach(action: (Map.Entry<K, V>) -> Unit): MapWrapper<K, V>

对每个元素执行给定的操作。

onEachIndexed

abstract fun onEachIndexed(action: (index: Int, Map.Entry<K, V>) -> Unit): MapWrapper<K, V>

对每个元素执行给定的操作，并提供元素的索引。

plus

abstract fun plus(map: Map<out K, V>): MapWrapper<K, V>

将指定的 map 添加到此 map 中，并返回一个新的 MapWrapper。

run

abstract fun <R> run(block: Map<K, V>.() -> R): ObjectWrapper<R>?

对 ObjectWrapper 调用给定的 block 函数，并返回 block 函数的结果包装在 ObjectWrapper 中。

takeIf

abstract fun takeIf(predicate: (Map<K, V>) -> Boolean): ObjectWrapper<Map<K, V>>?

如果 ObjectWrapper 满足给定的 predicate，则返回 ObjectWrapper 本身，否则返回 null 包装在 ObjectWrapper? 中。

takeUnless

abstract fun takeUnless(predicate: (Map<K, V>) -> Boolean): ObjectWrapper<Map<K, V>>?

如果 ObjectWrapper 不满足给定的 predicate，则返回 ObjectWrapper 本身，否则返回 null 包装在 ObjectWrapper? 中。

toList

abstract fun toList(): ListWrapper<Pair<K, V>>

将此 MapWrapper 转换为 ListWrapper，其中每个元素都是一个 Pair，表示 Map 中的一个键值对。

toMap

abstract fun <M : MutableMapWrapper<in K, in V>> toMap(destination: M): M

将此 MapWrapper 的所有 entry 复制到指定的 MutableMapWrapper 中。