sdk

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

SequenceWrapper

interface SequenceWrapper<T> : ObjectWrapper<Sequence<T>>

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

Author

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

Functions

abstract fun all(predicate: (T) -> Boolean): Boolean

检查序列中的所有元素是否都满足指定的谓词。

abstract fun also(block: (Sequence<T>) -> Unit): ObjectWrapper<Sequence<T>>

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

abstract fun any(predicate: (T) -> Boolean): Boolean

检查序列中是否存在至少一个元素满足指定的谓词。

abstract fun apply(block: Sequence<T>.() -> Unit): ObjectWrapper<Sequence<T>>

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

abstract fun asIterable(): IterableWrapper<T>

将序列转换为 IterableWrapper。

abstract fun asSequence(): SequenceWrapper<T>

返回序列本身，作为 SequenceWrapper。

abstract fun <K, V> associate(transform: (T) -> Pair<K, V>): MapWrapper<K, V>

将序列中的每个元素转换为一个键值对，并返回一个包含这些键值对的 MapWrapper。

abstract fun <K, V> associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): MapWrapper<K, V>

将序列中的每个元素与其对应的键关联起来，并返回一个包含这些键值对的 MapWrapper。

abstract fun <K, V, M : MutableMapWrapper<in K, in V>> associateByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

将序列中的每个元素与其对应的键关联起来，并将结果添加到指定的 MutableMapWrapper 中。

abstract fun <K, V, M : MutableMapWrapper<in K, in V>> associateTo(destination: M, transform: (T) -> Pair<K, V>): M

将序列中的每个元素转换为一个键值对，并将结果添加到指定的 MutableMapWrapper 中。

abstract fun <V> associateWith(valueSelector: (T) -> V): MapWrapper<T, V>

associateWithTo

abstract fun <V, M : MutableMapWrapper<in T, in V>> associateWithTo(destination: M, valueSelector: (T) -> V): M

将序列中的每个元素与其对应的值关联起来，并将结果添加到指定的 MutableMapWrapper 中。

abstract fun <R> chunked(size: Int, transform: (ListWrapper<T>) -> R): SequenceWrapper<R>

将序列拆分为指定大小的块，并对每个块应用指定的转换函数。

abstract fun contains(element: T): Boolean

检查序列是否包含指定的元素。

abstract fun count(): Int

返回序列中的元素数量。

abstract fun count(predicate: (T) -> Boolean): Int

返回序列中满足指定谓词的元素数量。

abstract fun distinct(): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中不同的元素。

abstract fun <K> distinctBy(selector: (T) -> K): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中根据指定的选择器函数选择出的不同元素。

abstract fun drop(n: Int): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中除前 n 个元素之外的所有元素。

abstract fun dropWhile(predicate: (T) -> Boolean): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中满足指定谓词的第一个元素之后的所有元素。

abstract fun elementAt(index: Int): T

返回指定索引处的元素。

elementAtOrElse

abstract fun elementAtOrElse(index: Int, defaultValue: (Int) -> T): T

返回指定索引处的元素，如果索引超出范围，则返回默认值。

elementAtOrNull

abstract fun elementAtOrNull(index: Int): T?

返回指定索引处的元素，如果索引超出范围，则返回 null。

abstract fun filter(predicate: (T) -> Boolean): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中满足指定谓词的所有元素。

abstract fun filterIndexed(predicate: (index: Int, T) -> Boolean): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中满足指定谓词的所有元素，并提供元素的索引。

filterIndexedTo

abstract fun <C : MutableCollectionWrapper<in T>> filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C

将序列中满足指定谓词的所有元素添加到指定的 MutableCollectionWrapper 中，并提供元素的索引。

abstract fun filterNot(predicate: (T) -> Boolean): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中不满足指定谓词的所有元素。

abstract fun <C : MutableCollectionWrapper<in T>> filterNotTo(destination: C, predicate: (T) -> Boolean): C

将序列中不满足指定谓词的所有元素添加到指定的 MutableCollectionWrapper 中。

abstract fun <C : MutableCollectionWrapper<in T>> filterTo(destination: C, predicate: (T) -> Boolean): C

将序列中满足指定谓词的所有元素添加到指定的 MutableCollectionWrapper 中。

abstract fun find(predicate: (T) -> Boolean): T?

返回序列中满足指定谓词的第一个元素。

abstract fun findLast(predicate: (T) -> Boolean): T?

返回序列中满足指定谓词的最后一个元素。

abstract fun first(predicate: (T) -> Boolean): T

返回序列中满足指定谓词的第一个元素。

abstract fun <R : Any> firstNotNullOf(transform: (T) -> R?): R

返回序列中应用指定转换函数后第一个不为 null 的结果。

firstNotNullOfOrNull

abstract fun <R : Any> firstNotNullOfOrNull(transform: (T) -> R?): R?

返回序列中应用指定转换函数后第一个不为 null 的结果，如果找不到则返回 null。

abstract fun firstOrNull(predicate: (T) -> Boolean): T?

返回序列中满足指定谓词的第一个元素，如果找不到则返回 null。

abstract fun <R> flatMap(transform: (T) -> Iterable<R>): SequenceWrapper<R>

将序列中的每个元素应用到指定的转换函数，并将结果展平为一个新的序列。

abstract fun <R> flatMapIndexed(transform: (index: Int, T) -> Iterable<R>): SequenceWrapper<R>

将序列中的每个元素应用到指定的转换函数，并将结果展平为一个新的序列，并提供元素的索引。

flatMapIndexedTo

abstract fun <R, C : MutableCollectionWrapper<in R>> flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Iterable<R>): C

将序列中的每个元素应用到指定的转换函数，并将结果展平并添加到指定的 MutableCollectionWrapper 中，并提供元素的索引。

abstract fun <R, C : MutableCollectionWrapper<in R>> flatMapTo(destination: C, transform: (T) -> Iterable<R>): C

将序列中的每个元素应用到指定的转换函数，并将结果展平并添加到指定的 MutableCollectionWrapper 中。

abstract fun <R> fold(initial: R, operation: (acc: R, T) -> R): R

对序列中的所有元素应用指定的累积操作，并返回累积结果。

abstract fun <R> foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R

对序列中的所有元素应用指定的累积操作，并返回累积结果，并提供元素的索引。

abstract fun forEach(action: (T) -> Unit)

对序列中的每个元素执行指定的操作。

abstract fun forEachIndexed(action: (index: Int, T) -> Unit)

对序列中的每个元素执行指定的操作，并提供元素的索引。

abstract override fun getOrigin(): Sequence<T>

获取被包装的对象.

abstract fun <K, V> groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): MapWrapper<K, List<V>>

将序列中的元素根据指定的键选择器函数分组，并返回一个 MapWrapper，其中包含每个键及其对应的元素列表。

abstract fun <K, V, M : MutableMapWrapper<in K, MutableList<V>>> groupByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

将序列中的元素根据指定的键选择器函数分组，并将结果添加到指定的 MutableMapWrapper 中。

abstract fun <K> groupingBy(keySelector: (T) -> K): GroupingWrapper<T, K>

返回一个 GroupingWrapper，它允许对序列中的元素进行分组操作。

abstract fun indexOf(element: T): Int

返回序列中指定元素的第一个索引。

abstract fun indexOfFirst(predicate: (T) -> Boolean): Int

返回序列中满足指定谓词的第一个元素的索引。

abstract fun indexOfLast(predicate: (T) -> Boolean): Int

返回序列中满足指定谓词的最后一个元素的索引。

abstract fun <A : Appendable> joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): A

将序列中的元素连接到指定的 Appendable 对象中，并使用指定的分隔符、前缀、后缀、限制和截断符。

abstract fun joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence? = null): String

将序列中的元素连接成一个字符串，并使用指定的分隔符、前缀、后缀、限制和截断符。

abstract fun last(predicate: (T) -> Boolean): T

返回序列中满足指定谓词的最后一个元素。

abstract fun lastIndexOf(element: T): Int

返回序列中指定元素的最后一个索引。

abstract fun lastOrNull(predicate: (T) -> Boolean): T?

返回序列中满足指定谓词的最后一个元素，如果找不到则返回 null。

abstract fun <R> let(block: (Sequence<T>) -> R): ObjectWrapper<R>?

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

abstract fun <R> map(transform: (T) -> R): SequenceWrapper<R>

将序列中的每个元素应用到指定的转换函数，并返回一个新的 SequenceWrapper，其中包含转换后的元素。

abstract fun <R> mapIndexed(transform: (index: Int, T) -> R): SequenceWrapper<R>

将序列中的每个元素应用到指定的转换函数，并返回一个新的 SequenceWrapper，其中包含转换后的元素，并提供元素的索引。

mapIndexedNotNull

abstract fun <R : Any> mapIndexedNotNull(transform: (index: Int, T) -> R?): SequenceWrapper<R>

将序列中的每个元素应用到指定的转换函数，并返回一个新的 SequenceWrapper，其中包含转换后的非空元素，并提供元素的索引。

mapIndexedNotNullTo

abstract fun <R : Any, C : MutableCollectionWrapper<in R>> mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C

将序列中的每个元素应用到指定的转换函数，并将转换后的非空元素添加到指定的 MutableCollectionWrapper 中，并提供元素的索引。

abstract fun <R, C : MutableCollectionWrapper<in R>> mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C

将序列中的每个元素应用到指定的转换函数，并将转换后的元素添加到指定的 MutableCollectionWrapper 中，并提供元素的索引。

abstract fun <R : Any> mapNotNull(transform: (T) -> R?): SequenceWrapper<R>

将序列中的每个元素应用到指定的转换函数，并返回一个新的 SequenceWrapper，其中包含转换后的非空元素。

abstract fun <R : Any, C : MutableCollectionWrapper<in R>> mapNotNullTo(destination: C, transform: (T) -> R?): C

将序列中的每个元素应用到指定的转换函数，并将转换后的非空元素添加到指定的 MutableCollectionWrapper 中。

abstract fun <R, C : MutableCollectionWrapper<in R>> mapTo(destination: C, transform: (T) -> R): C

将序列中的每个元素应用到指定的转换函数，并将转换后的元素添加到指定的 MutableCollectionWrapper 中。

abstract fun <R : Comparable<R>> maxByOrNull(selector: (T) -> R): T?

返回根据指定的选择器函数从序列中选择出的最大元素。

abstract fun <R : Comparable<R>> maxOf(selector: (T) -> R): R

返回根据指定的选择器函数从序列中选择出的元素的最大值。

abstract fun <R : Comparable<R>> maxOfOrNull(selector: (T) -> R): R?

返回根据指定的选择器函数从序列中选择出的元素的最大值，如果序列为空则返回 null。

abstract fun <R> maxOfWith(comparator: Comparator<in R>, selector: (T) -> R): R

返回根据指定的选择器函数和比较器从序列中选择出的元素的最大值。

maxOfWithOrNull

abstract fun <R> maxOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?

返回根据指定的选择器函数和比较器从序列中选择出的元素的最大值，如果序列为空则返回 null。

abstract fun maxWith(comparator: Comparator<in T>): T

返回根据指定的比较器从序列中选择出的最大元素。

abstract fun maxWithOrNull(comparator: Comparator<in T>): T?

返回根据指定的比较器从序列中选择出的最大元素，如果序列为空则返回 null。

abstract fun <R : Comparable<R>> minByOrNull(selector: (T) -> R): T?

返回根据指定的选择器函数从序列中选择出的最小元素。

abstract fun <R : Comparable<R>> minOf(selector: (T) -> R): R

返回根据指定的选择器函数从序列中选择出的元素的最小值。

abstract fun <R : Comparable<R>> minOfOrNull(selector: (T) -> R): R?

返回根据指定的选择器函数从序列中选择出的元素的最小值，如果序列为空则返回 null。

abstract fun <R> minOfWith(comparator: Comparator<in R>, selector: (T) -> R): R

返回根据指定的选择器函数和比较器从序列中选择出的元素的最小值。

minOfWithOrNull

abstract fun <R> minOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?

返回根据指定的选择器函数和比较器从序列中选择出的元素的最小值，如果序列为空则返回 null。

abstract fun minus(elements: Iterable<T>): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中除指定元素之外的所有元素。

abstract fun minWith(comparator: Comparator<in T>): T

返回根据指定的比较器从序列中选择出的最小元素。

abstract fun minWithOrNull(comparator: Comparator<in T>): T?

返回根据指定的比较器从序列中选择出的最小元素，如果序列为空则返回 null。

abstract fun none(predicate: (T) -> Boolean): Boolean

检查序列中是否没有元素满足指定的谓词。

abstract fun onEach(action: (T) -> Unit): SequenceWrapper<T>

对序列中的每个元素执行指定的操作，而不会修改序列本身。

abstract fun onEachIndexed(action: (index: Int, T) -> Unit): SequenceWrapper<T>

abstract fun partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>

将序列中的元素根据指定的谓词分成两个列表。

abstract fun plus(elements: Iterable<T>): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中的所有元素，以及指定的元素。

abstract fun reduce(operation: (T, T) -> T): T

对序列中的所有元素应用指定的累积操作，并返回累积结果。

abstract fun reduceIndexed(operation: (index: Int, acc: T, T) -> T): T

对序列中的所有元素应用指定的累积操作，并返回累积结果，并提供元素的索引。

reduceIndexedOrNull

abstract fun reduceIndexedOrNull(operation: (index: Int, acc: T, T) -> T): T?

对序列中的所有元素应用指定的累积操作，并返回累积结果，并提供元素的索引。如果序列为空，则返回 null。

abstract fun reduceOrNull(operation: (acc: T, T) -> T): T?

对序列中的所有元素应用指定的累积操作，并返回累积结果。如果序列为空，则返回 null。

abstract fun requireNoNulls(): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中不包含任何 null 元素。

abstract fun <R> run(block: Sequence<T>.() -> R): ObjectWrapper<R>?

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

abstract fun <R> runningFold(initial: R, operation: (acc: R, T) -> R): SequenceWrapper<R>

对序列中的元素应用指定的累积操作，并返回一个新的序列，其中包含每个步骤的累积结果。

runningFoldIndexed

abstract fun <R> runningFoldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): SequenceWrapper<R>

对序列中的元素应用指定的累积操作，并返回一个新的序列，其中包含每个步骤的累积结果，并提供元素的索引。

abstract fun runningReduce(operation: (acc: T, T) -> T): SequenceWrapper<T>

对序列中的元素应用指定的累积操作，并返回一个新的序列，其中包含每个步骤的累积结果。

runningReduceIndexed

abstract fun runningReduceIndexed(operation: (index: Int, acc: T, T) -> T): SequenceWrapper<T>

对序列中的元素应用指定的累积操作，并返回一个新的序列，其中包含每个步骤的累积结果，并提供元素的索引。

abstract fun <R> scan(initial: R, operation: (acc: R, T) -> R): SequenceWrapper<R>

对序列中的元素应用指定的累积操作，并返回一个新的序列，其中包含每个步骤的累积结果。

abstract fun <R> scanIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): SequenceWrapper<R>

对序列中的元素应用指定的累积操作，并返回一个新的序列，其中包含每个步骤的累积结果，并提供元素的索引。

abstract fun single(predicate: (T) -> Boolean): T

返回序列中满足指定谓词的唯一元素。

abstract fun singleOrNull(predicate: (T) -> Boolean): T?

返回序列中满足指定谓词的唯一元素，如果找不到则返回 null。

abstract fun <R : Comparable<R>> sortedBy(selector: (T) -> R?): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中根据指定的选择器函数选择出的元素排序后的元素。

sortedByDescending

abstract fun <R : Comparable<R>> sortedByDescending(selector: (T) -> R?): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中根据指定的选择器函数选择出的元素以降序排序后的元素。

abstract fun sortedWith(comparator: Comparator<in T>): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中根据指定的比较器排序后的元素。

abstract fun take(n: Int): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中的前 n 个元素。

abstract fun takeIf(predicate: (Sequence<T>) -> Boolean): ObjectWrapper<Sequence<T>>?

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

abstract fun takeUnless(predicate: (Sequence<T>) -> Boolean): ObjectWrapper<Sequence<T>>?

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

abstract fun takeWhile(predicate: (T) -> Boolean): SequenceWrapper<T>

返回一个新的 SequenceWrapper，其中包含原始序列中满足指定谓词的元素，直到第一个不满足谓词的元素为止。

abstract fun <C : MutableCollectionWrapper<in T>> toCollection(destination: C): C

将序列中的所有元素添加到指定的 MutableCollectionWrapper 中。

abstract fun <R> windowed(size: Int, step: Int = 1, partialWindows: Boolean = false, transform: (ListWrapper<T>) -> R): SequenceWrapper<R>

将序列中的元素以窗口的形式分组，并对每个窗口应用指定的转换函数。

abstract fun withIndex(): SequenceWrapper<IndexedValue<T>>

返回一个新的 SequenceWrapper，其中包含原始序列中每个元素及其索引的配对。

abstract fun <R, V> zip(other: SequenceWrapper<R>, transform: (a: T, b: R) -> V): SequenceWrapper<V>

将两个序列按元素组合成一个新的序列，其中每个元素都是一个 Pair，包含来自两个序列的对应元素。

abstract fun <R> zipWithNext(transform: (a: T, b: T) -> R): SequenceWrapper<R>

将序列中的每个元素与其后面的元素组合成一个新的序列，其中每个元素都是一个 Pair，包含来自原始序列的两个相邻元素。