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

CharSequenceWrapper

interface CharSequenceWrapper : ObjectWrapper<CharSequence>

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

Author

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

Inheritors

StringWrapper

Functions

all

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

如果 CharSequenceWrapper 中的所有字符都匹配给定的谓词，则返回 true。

also

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

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

any

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

如果 CharSequenceWrapper 中至少有一个字符匹配给定的谓词，则返回 true。

apply

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

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

associate

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

将 CharSequenceWrapper 中的每个字符转换为一个键值对，并返回一个新的 MapWrapper。

associateBy

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

将 CharSequenceWrapper 中的每个字符转换为一个键值对，并返回一个新的 MapWrapper。

associateByTo

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

将 CharSequenceWrapper 中的每个字符转换为一个键值对，并将结果添加到目标 MutableMapWrapper 中。

associateTo

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

将 CharSequenceWrapper 中的每个字符转换为一个键值对，并将结果添加到目标 MutableMapWrapper 中。

associateWith

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

将 CharSequenceWrapper 中的每个字符与指定值关联，并返回一个新的 MapWrapper。

associateWithTo

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

将 CharSequenceWrapper 中的每个字符与指定值关联，并将结果添加到目标 MutableMapWrapper 中。

chunked

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

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

contains

abstract fun contains(element: Char): Boolean

如果 CharSequenceWrapper 包含指定的元素，则返回 true。

count

abstract fun count(): Int

返回 CharSequenceWrapper 中的元素数量。

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

返回 CharSequenceWrapper 中与给定谓词匹配的元素数量。

drop

abstract fun drop(n: Int): CharSequenceWrapper

返回一个 CharSequenceWrapper，其中包含原始 CharSequenceWrapper 中除前 n 个字符之外的所有字符。

dropLast

abstract fun dropLast(n: Int): CharSequenceWrapper

返回一个 CharSequenceWrapper，其中包含原始 CharSequenceWrapper 中除最后 n 个字符之外的所有字符。

dropLastWhile

abstract fun dropLastWhile(predicate: (Char) -> Boolean): CharSequenceWrapper

返回一个 CharSequenceWrapper，其中包含原始 CharSequenceWrapper 中除满足给定谓词的最后一个字符之外的所有字符。

dropWhile

abstract fun dropWhile(predicate: (Char) -> Boolean): CharSequenceWrapper

返回一个 CharSequenceWrapper，其中包含原始 CharSequenceWrapper 中除满足给定谓词的第一个字符之外的所有字符。

elementAt

abstract fun elementAt(index: Int): Char

返回指定索引处的元素。

elementAtOrElse

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

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

elementAtOrNull

abstract fun elementAtOrNull(index: Int): Char?

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

filter

abstract fun filter(predicate: (Char) -> Boolean): CharSequence

返回一个 CharSequence，其中包含原始 CharSequenceWrapper 中满足给定谓词的所有字符。

filterIndexed

abstract fun filterIndexed(predicate: (index: Int, Char) -> Boolean): CharSequence

返回一个 CharSequence，其中包含原始 CharSequenceWrapper 中满足给定谓词的所有字符，并提供字符的索引。

filterIndexedTo

abstract fun <C : Appendable> filterIndexedTo(destination: C, predicate: (index: Int, Char) -> Boolean): C

将原始 CharSequenceWrapper 中满足给定谓词的所有字符添加到目标 Appendable 中，并提供字符的索引。

filterNot

abstract fun filterNot(predicate: (Char) -> Boolean): CharSequence

返回一个 CharSequence，其中包含原始 CharSequenceWrapper 中不满足给定谓词的所有字符。

filterNotTo

abstract fun <C : Appendable> filterNotTo(destination: C, predicate: (Char) -> Boolean): C

将原始 CharSequenceWrapper 中不满足给定谓词的所有字符添加到目标 Appendable 中。

filterTo

abstract fun <C : Appendable> filterTo(destination: C, predicate: (Char) -> Boolean): C

将原始 CharSequenceWrapper 中满足给定谓词的所有字符添加到目标 Appendable 中。

find

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

返回 CharSequenceWrapper 中与给定谓词匹配的第一个元素。

findLast

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

返回 CharSequenceWrapper 中与给定谓词匹配的最后一个元素。

first

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

返回 CharSequenceWrapper 中与给定谓词匹配的第一个元素。

firstNotNullOf

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

返回 CharSequenceWrapper 中应用给定转换函数后产生的第一个非空元素。

firstNotNullOfOrNull

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

返回 CharSequenceWrapper 中应用给定转换函数后产生的第一个非空元素，如果没有找到则返回 null。

firstOrNull

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

返回 CharSequenceWrapper 中与给定谓词匹配的第一个元素，如果没有找到则返回 null。

flatMap

abstract fun <R> flatMap(transform: (Char) -> Iterable<R>): ListWrapper<R>

返回一个 ListWrapper，其中包含将给定转换函数应用于原始 CharSequenceWrapper 的每个字符的结果，并将结果连接成一个列表。

flatMapIndexed

abstract fun <R> flatMapIndexed(transform: (index: Int, Char) -> Iterable<R>): ListWrapper<R>

返回一个 ListWrapper，其中包含将给定转换函数应用于原始 CharSequenceWrapper 的每个字符的结果，并将结果连接成一个列表，同时提供字符的索引。

flatMapIndexedTo

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

将给定转换函数应用于原始 CharSequenceWrapper 的每个字符的结果，并将结果连接成一个列表，同时提供字符的索引，并将结果添加到目标 MutableCollectionWrapper 中。

flatMapTo

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

将给定转换函数应用于原始 CharSequenceWrapper 的每个字符的结果，并将结果连接成一个列表，并将结果添加到目标 MutableCollectionWrapper 中。

fold

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

将初始值与 CharSequenceWrapper 中的所有元素聚合，使用提供的操作函数依次将每个元素与累积结果组合。

foldIndexed

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

将初始值与 CharSequenceWrapper 中的所有元素聚合，使用提供的操作函数依次将每个元素与累积结果组合，并提供元素的索引。

foldRight

abstract fun <R> foldRight(initial: R, operation: (Char, acc: R) -> R): R

将初始值与 CharSequenceWrapper 中的所有元素聚合，使用提供的操作函数依次将每个元素与累积结果组合，从最后一个元素开始。

foldRightIndexed

abstract fun <R> foldRightIndexed(initial: R, operation: (index: Int, Char, acc: R) -> R): R

将初始值与 CharSequenceWrapper 中的所有元素聚合，使用提供的操作函数依次将每个元素与累积结果组合，从最后一个元素开始，并提供元素的索引。

forEach

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

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

forEachIndexed

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

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

getOrElse

abstract fun getOrElse(index: Int, defaultValue: (Int) -> Char): Char

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

getOrigin

abstract override fun getOrigin(): CharSequence

获取被包装的对象.

groupBy

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

将 CharSequenceWrapper 中的元素分组到一个 MapWrapper 中，其中键由 keySelector 函数选择，值是具有相同键的元素的列表。

groupByTo

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

将 CharSequenceWrapper 中的元素分组到一个 MutableMapWrapper 中，其中键由 keySelector 函数选择，值是具有相同键的元素的列表。

groupingBy

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

返回一个 GroupingWrapper，它允许按 keySelector 函数选择的键对 CharSequenceWrapper 中的元素进行分组。

indexOf

abstract fun indexOf(element: Char): Int

返回 CharSequenceWrapper 中指定元素的第一个索引，如果未找到该元素，则返回 -1。

indexOfFirst

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

返回 CharSequenceWrapper 中满足给定谓词的第一个元素的索引，如果未找到此类元素，则返回 -1。

indexOfLast

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

返回 CharSequenceWrapper 中满足给定谓词的最后一个元素的索引，如果未找到此类元素，则返回 -1。

last

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

返回 CharSequenceWrapper 中满足给定谓词的最后一个元素。

lastIndexOf

abstract fun lastIndexOf(element: Char): Int

返回 CharSequenceWrapper 中指定元素的最后一个索引，如果未找到该元素，则返回 -1。

lastOrNull

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

返回 CharSequenceWrapper 中满足给定谓词的最后一个元素，如果未找到此类元素，则返回 null。

let

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

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

map

abstract fun <R> map(transform: (Char) -> R): ListWrapper<R>

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

mapIndexed

abstract fun <R> mapIndexed(transform: (index: Int, Char) -> R): ListWrapper<R>

返回一个 ListWrapper，其中包含将给定转换函数应用于原始 CharSequenceWrapper 的每个元素的结果，并提供元素的索引。

mapIndexedNotNull

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

返回一个 ListWrapper，其中包含将给定转换函数应用于原始 CharSequenceWrapper 的每个元素的结果，并提供元素的索引，并过滤掉所有 null 结果。

mapIndexedNotNullTo

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

将给定转换函数应用于原始 CharSequenceWrapper 的每个元素的结果，并提供元素的索引，并过滤掉所有 null 结果，并将结果添加到目标 MutableCollectionWrapper 中。

mapIndexedTo

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

将给定转换函数应用于原始 CharSequenceWrapper 的每个元素的结果，并提供元素的索引，并将结果添加到目标 MutableCollectionWrapper 中。

mapNotNull

abstract fun <R : Any> mapNotNull(transform: (Char) -> R?): ListWrapper<R>

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

mapNotNullTo

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

将给定转换函数应用于原始 CharSequenceWrapper 的每个元素的结果，并过滤掉所有 null 结果，并将结果添加到目标 MutableCollectionWrapper 中。

mapTo

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

将给定转换函数应用于原始 CharSequenceWrapper 的每个元素的结果，并将结果添加到目标 MutableCollectionWrapper 中。

maxByOrNull

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

返回 CharSequenceWrapper 中按 selector 函数选择的值最大的元素，如果 CharSequenceWrapper 为空或没有最大值，则返回 null。

maxOf

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

返回 CharSequenceWrapper 中按 selector 函数选择的值的最大值。

maxOfOrNull

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

返回 CharSequenceWrapper 中按 selector 函数选择的值的最大值，如果 CharSequenceWrapper 为空，则返回 null。

maxOfWith

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

返回 CharSequenceWrapper 中按 selector 函数选择的值和比较器比较的最大值。

maxOfWithOrNull

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

返回 CharSequenceWrapper 中按 selector 函数选择的值和比较器比较的最大值，如果 CharSequenceWrapper 为空，则返回 null。

maxWith

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

返回 CharSequenceWrapper 中按比较器比较的最大元素。

maxWithOrNull

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

返回 CharSequenceWrapper 中按比较器比较的最大元素，如果 CharSequenceWrapper 为空，则返回 null。

minByOrNull

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

返回 CharSequenceWrapper 中按 selector 函数选择的值最小的元素，如果 CharSequenceWrapper 为空或没有最小值，则返回 null。

minOf

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

返回 CharSequenceWrapper 中按 selector 函数选择的值的最小值。

minOfOrNull

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

返回 CharSequenceWrapper 中按 selector 函数选择的值的最小值，如果 CharSequenceWrapper 为空，则返回 null。

minOfWith

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

返回 CharSequenceWrapper 中按 selector 函数选择的值和比较器比较的最小值。

minOfWithOrNull

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

返回 CharSequenceWrapper 中按 selector 函数选择的值和比较器比较的最小值，如果 CharSequenceWrapper 为空，则返回 null。

minWith

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

返回 CharSequenceWrapper 中按比较器比较的最小元素。

minWithOrNull

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

返回 CharSequenceWrapper 中按比较器比较的最小元素，如果 CharSequenceWrapper 为空，则返回 null。

none

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

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

onEach

abstract fun onEach(action: (Char) -> Unit): CharSequenceWrapper

对每个字符执行给定的操作。

onEachIndexed

abstract fun onEachIndexed(action: (index: Int, Char) -> Unit): CharSequenceWrapper

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

partition

abstract fun partition(predicate: (Char) -> Boolean): Pair<CharSequence, CharSequence>

将原始 CharSequenceWrapper 的元素分成两个 CharSequence，其中第一个 CharSequence 包含满足给定谓词的元素，第二个 CharSequence 包含其余元素。

reduce

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

将给定操作顺序应用于 CharSequenceWrapper 的每个元素和当前累积结果，以将 CharSequenceWrapper 的所有元素减少为单个结果。

reduceIndexed

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

将给定操作顺序应用于 CharSequenceWrapper 的每个元素（以及其索引）和当前累积结果，以将 CharSequenceWrapper 的所有元素减少为单个结果。

reduceIndexedOrNull

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

将给定操作顺序应用于 CharSequenceWrapper 的每个元素（以及其索引）和当前累积结果，以将 CharSequenceWrapper 的所有元素减少为单个结果，如果 CharSequenceWrapper 为空，则返回 null。

reduceOrNull

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

将给定操作顺序应用于 CharSequenceWrapper 的每个元素和当前累积结果，以将 CharSequenceWrapper 的所有元素减少为单个结果，如果 CharSequenceWrapper 为空，则返回 null。

reduceRight

abstract fun reduceRight(operation: (Char, acc: Char) -> Char): Char

将给定操作顺序应用于 CharSequenceWrapper 的每个元素和当前累积结果，以将 CharSequenceWrapper 的所有元素减少为单个结果，从最后一个元素开始。

reduceRightIndexed

abstract fun reduceRightIndexed(operation: (index: Int, Char, acc: Char) -> Char): Char

将给定操作顺序应用于 CharSequenceWrapper 的每个元素（以及其索引）和当前累积结果，以将 CharSequenceWrapper 的所有元素减少为单个结果，从最后一个元素开始。

reduceRightIndexedOrNull

abstract fun reduceRightIndexedOrNull(operation: (index: Int, Char, acc: Char) -> Char): Char?

将给定操作顺序应用于 CharSequenceWrapper 的每个元素（以及其索引）和当前累积结果，以将 CharSequenceWrapper 的所有元素减少为单个结果，从最后一个元素开始，如果 CharSequenceWrapper 为空，则返回 null。

reduceRightOrNull

abstract fun reduceRightOrNull(operation: (Char, acc: Char) -> Char): Char?

将给定操作顺序应用于 CharSequenceWrapper 的每个元素和当前累积结果，以将 CharSequenceWrapper 的所有元素减少为单个结果，从最后一个元素开始，如果 CharSequenceWrapper 为空，则返回 null。

run

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

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

runningFold

abstract fun <R> runningFold(initial: R, operation: (acc: R, Char) -> R): ListWrapper<R>

返回一个 ListWrapper，其中包含通过将给定操作顺序应用于初始值和 CharSequenceWrapper 的每个元素而获得的中间结果。

runningFoldIndexed

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

返回一个 ListWrapper，其中包含通过将给定操作顺序应用于初始值和 CharSequenceWrapper 的每个元素（以及其索引）而获得的中间结果。

runningReduce

abstract fun runningReduce(operation: (acc: Char, Char) -> Char): ListWrapper<Char>

返回一个 ListWrapper，其中包含通过将给定操作顺序应用于 CharSequenceWrapper 的每个元素和当前累积结果而获得的中间结果。

runningReduceIndexed

abstract fun runningReduceIndexed(operation: (index: Int, acc: Char, Char) -> Char): ListWrapper<Char>

返回一个 ListWrapper，其中包含通过将给定操作顺序应用于 CharSequenceWrapper 的每个元素（以及其索引）和当前累积结果而获得的中间结果。

scan

abstract fun <R> scan(initial: R, operation: (acc: R, Char) -> R): ListWrapper<R>

返回一个 ListWrapper，其中包含通过将给定操作顺序应用于初始值和 CharSequenceWrapper 的每个元素而获得的中间结果。

scanIndexed

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

返回一个 ListWrapper，其中包含通过将给定操作顺序应用于初始值和 CharSequenceWrapper 的每个元素（以及其索引）而获得的中间结果。

single

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

返回 CharSequenceWrapper 中满足给定谓词的唯一元素。

singleOrNull

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

返回 CharSequenceWrapper 中满足给定谓词的唯一元素，如果没有找到或有多个元素满足给定谓词，则返回 null。

take

abstract fun take(n: Int): CharSequenceWrapper

返回一个 CharSequenceWrapper，其中包含原始 CharSequenceWrapper 的前 n 个字符。

takeIf

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

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

takeLastWhile

abstract fun takeLastWhile(predicate: (Char) -> Boolean): CharSequenceWrapper

返回一个 CharSequenceWrapper，其中包含原始 CharSequenceWrapper 中满足给定谓词的最后一个字符，从最后一个字符开始。

takeUnless

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

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

takeWhile

abstract fun takeWhile(predicate: (Char) -> Boolean): CharSequenceWrapper

返回一个 CharSequenceWrapper，其中包含原始 CharSequenceWrapper 中满足给定谓词的第一个字符，从第一个字符开始。

toCollection

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

将 CharSequenceWrapper 中的所有字符添加到目标 MutableCollectionWrapper 中。

toHashSet

abstract fun toHashSet(): SetWrapper<Char>

返回一个 SetWrapper，其中包含 CharSequenceWrapper 中的所有字符。

toList

abstract fun toList(): ListWrapper<Char>

返回一个 ListWrapper，其中包含 CharSequenceWrapper 中的所有字符。

toMutableList

abstract fun toMutableList(): ListWrapper<Char>

返回一个 ListWrapper，其中包含 CharSequenceWrapper 中的所有字符。

toSet

abstract fun toSet(): SetWrapper<Char>

返回一个 SetWrapper，其中包含 CharSequenceWrapper 中的所有字符。

windowed

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

返回一个 ListWrapper，其中包含通过将给定转换函数应用于原始 CharSequenceWrapper 的滑动窗口而获得的结果。

withIndex

abstract fun withIndex(): IterableWrapper<IndexedValue<Char>>

返回一个 IterableWrapper，其中包含原始 CharSequenceWrapper 中的每个字符及其索引。

zip

abstract fun <V> zip(other: CharSequence, transform: (Char, Char) -> V): ListWrapper<V>

将 CharSequenceWrapper 与另一个 CharSequence 组合，使用提供的转换函数将每个字符对组合成一个新的元素。

zipWithNext

abstract fun <R> zipWithNext(transform: (a: Char, b: Char) -> R): ListWrapper<R>

将 CharSequenceWrapper 中的每个字符与其下一个字符组合，使用提供的转换函数将每个字符对组合成一个新的元素。