sdk

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

FloatArrayWrapper

interface FloatArrayWrapper : PrimitiveArrayWrapper<Float, FloatArray>

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

Author

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

Functions

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

如果此数组的所有元素都满足给定的谓词，则返回 true.

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

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

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

如果此数组的任何元素都满足给定的谓词，则返回 true.

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

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

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

将此数组的每个元素与其对应的键值对关联起来，并返回一个新的 MapWrapper.

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

将此数组的每个元素与其对应的键关联起来，并返回一个新的 MapWrapper.

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

将此数组的每个元素与其对应的键关联起来，并将结果添加到给定的 MutableMapWrapper 中.

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

将此数组的每个元素与其对应的键值对关联起来，并将结果添加到给定的 MutableMapWrapper 中.

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

将此数组的每个元素与其对应的值关联起来，并返回一个新的 MapWrapper.

associateWithTo

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

将此数组的每个元素与其对应的值关联起来，并将结果添加到给定的 MutableMapWrapper 中.

contentToString

abstract fun contentToString(): String

返回此数组内容的字符串表示形式。

abstract fun copyInto(destination: PrimitiveArrayWrapper<Float, FloatArray>, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int): PrimitiveArrayWrapper<Float, FloatArray>

将此数组的元素复制到给定的 PrimitiveArrayWrapper 中.

abstract fun copyOf(newSize: Int): PrimitiveArrayWrapper<Float, FloatArray>

创建一个具有指定大小的新数组，并用此数组的元素填充它.

abstract fun copyOfRange(fromIndex: Int, toIndex: Int): PrimitiveArrayWrapper<Float, FloatArray>

创建一个新数组，并用此数组指定范围内的元素填充它.

abstract fun count(): Int

获取数组元素数量.

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

返回此数组中满足给定谓词的元素数量.

abstract fun distinct(): ListWrapper<Float>

获取数组中不重复的元素列表.

abstract fun <K> distinctBy(selector: (Float) -> K): ListWrapper<Float>

根据给定的选择器函数获取数组中不重复的元素列表.

abstract fun drop(n: Int): ListWrapper<Float>

返回删除前 n 个元素的新列表.

abstract fun dropLast(n: Int): ListWrapper<Float>

返回删除最后 n 个元素的新列表.

abstract fun dropLastWhile(predicate: (Float) -> Boolean): ListWrapper<Float>

返回删除满足给定谓词的最后几个元素的新列表.

abstract fun dropWhile(predicate: (Float) -> Boolean): ListWrapper<Float>

返回删除满足给定谓词的开头几个元素的新列表.

abstract fun elementAt(index: Int): Float

获取指定索引处的元素.

elementAtOrElse

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

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

elementAtOrNull

abstract fun elementAtOrNull(index: Int): Float?

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

abstract fun fill(element: Float, fromIndex: Int = 0, toIndex: Int)

用给定的元素填充此数组的指定范围.

abstract fun filter(predicate: (Float) -> Boolean): ListWrapper<Float>

返回由满足给定谓词的元素组成的新列表.

abstract fun filterIndexed(predicate: (index: Int, Float) -> Boolean): ListWrapper<Float>

返回由满足给定谓词的元素组成的新列表，并提供元素索引.

filterIndexedTo

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

将满足给定谓词的元素添加到目标集合中，并提供元素索引.

abstract fun filterNot(predicate: (Float) -> Boolean): ListWrapper<Float>

返回由不满足给定谓词的元素组成的新列表.

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

将不满足给定谓词的元素添加到目标集合中.

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

将满足给定谓词的元素添加到目标集合中.

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

查找第一个满足给定谓词的元素.

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

查找最后一个满足给定谓词的元素.

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

返回第一个满足给定谓词的元素.

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

返回第一个满足给定谓词的元素，如果没有找到，则返回 null.

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

将每个元素转换为一个 Iterable，并将结果合并为一个新列表.

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

将每个元素转换为一个 Iterable，并将结果合并为一个新列表，并提供元素索引.

flatMapIndexedTo

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

将每个元素转换为一个 Iterable，并将结果添加到目标集合中，并提供元素索引.

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

将每个元素转换为一个 Iterable，并将结果添加到目标集合中.

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

通过对每个元素应用操作来累积值.

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

通过对每个元素应用操作来累积值，并提供元素索引.

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

通过从最后一个元素到第一个元素应用操作来累积值.

foldRightIndexed

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

通过从最后一个元素到第一个元素应用操作来累积值，并提供元素索引.

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

对数组的每个元素执行给定的操作.

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

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

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

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

abstract override fun getOrigin(): FloatArray

获取被包装的对象.

abstract fun getOrNull(index: Int): Float?

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

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

根据给定的键选择器函数将数组元素分组到一个 Map 中.

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

根据给定的键选择器函数将数组元素分组到一个目标 Map 中.

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

查找第一个满足给定谓词的元素的索引.

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

查找最后一个满足给定谓词的元素的索引.

abstract fun intersect(other: Iterable<Float>): SetWrapper<Float>

返回此数组和给定 Iterable 的交集.

abstract fun isEmpty(): Boolean

检查数组是否为空.

abstract fun isNotEmpty(): Boolean

检查数组是否不为空.

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

将数组元素连接到给定的 Appendable 对象中.

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

将数组元素连接成一个字符串.

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

返回最后一个满足给定谓词的元素.

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

返回最后一个满足给定谓词的元素，如果没有找到，则返回 null.

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

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

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

将每个元素转换为一个新元素，并返回一个包含所有转换结果的新列表.

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

将每个元素转换为一个新元素，并提供元素索引，并返回一个包含所有转换结果的新列表.

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

将每个元素转换为一个新元素，并提供元素索引，并将结果添加到目标集合中.

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

将每个元素转换为一个新元素，并将结果添加到目标集合中.

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

返回根据给定选择器函数选择的最大元素，如果没有找到，则返回 null.

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

返回根据给定选择器函数选择的最大值.

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

返回根据给定选择器函数选择的最大值，如果没有找到，则返回 null.

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

返回根据给定选择器函数选择的最小元素，如果没有找到，则返回 null.

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

返回根据给定选择器函数选择的最小值.

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

返回根据给定选择器函数选择的最小值，如果没有找到，则返回 null.

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

如果数组中没有元素满足给定谓词，则返回 true.

abstract fun onEach(action: (Float) -> Unit): PrimitiveArrayWrapper<Float, FloatArray>

对数组的每个元素执行给定的操作，并返回数组本身.

abstract fun onEachIndexed(action: (index: Int, Float) -> Unit): PrimitiveArrayWrapper<Float, FloatArray>

对数组的每个元素执行给定的操作，并提供元素索引，并返回数组本身.

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

将数组拆分为两个列表，一个包含满足给定谓词的元素，另一个包含不满足的元素.

abstract fun plus(elements: Collection<Float>): PrimitiveArrayWrapper<Float, FloatArray>

返回一个包含此数组元素和给定集合元素的新数组.

abstract fun random(random: Random): Float

返回数组中的一个随机元素.

abstract fun randomOrNull(random: Random): Float?

返回数组中的一个随机元素，如果没有找到，则返回 null.

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

通过对数组元素应用操作来累积值.

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

通过对数组元素应用操作来累积值，并提供元素索引.

reduceIndexedOrNull

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

通过对数组元素应用操作来累积值，并提供元素索引，如果没有找到，则返回 null.

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

通过对数组元素应用操作来累积值，如果没有找到，则返回 null.

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

通过从最后一个元素到第一个元素应用操作来累积值.

reduceRightIndexed

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

通过从最后一个元素到第一个元素应用操作来累积值，并提供元素索引.

reduceRightIndexedOrNull

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

通过从最后一个元素到第一个元素应用操作来累积值，并提供元素索引，如果没有找到，则返回 null.

reduceRightOrNull

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

通过从最后一个元素到第一个元素应用操作来累积值，如果没有找到，则返回 null.

abstract fun reverse(fromIndex: Int, toIndex: Int)

反转此数组指定范围内的元素顺序.

abstract fun reversed(): ListWrapper<Float>

返回一个包含数组元素反转顺序的新列表.

abstract fun reversedArray(): PrimitiveArrayWrapper<Float, FloatArray>

返回一个包含此数组元素反转顺序的新数组.

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

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

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

返回一个列表，其中包含对数组元素应用操作的累积结果.

runningFoldIndexed

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

返回一个列表，其中包含对数组元素应用操作的累积结果，并提供元素索引.

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

返回一个列表，其中包含对数组元素应用操作的累积结果.

runningReduceIndexed

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

返回一个列表，其中包含对数组元素应用操作的累积结果，并提供元素索引.

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

返回一个列表，其中包含对数组元素应用操作的累积结果.

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

返回一个列表，其中包含对数组元素应用操作的累积结果，并提供元素索引.

abstract fun set(index: Int, value: Float)

设置指定索引处的元素值.

abstract fun shuffle(random: Random)

使用给定的随机数生成器随机排列此数组的元素.

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

返回满足给定谓词的唯一元素.

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

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

abstract fun slice(indices: Iterable<Int>): ListWrapper<Float>

返回一个列表，其中包含由给定索引指定的元素.

abstract fun sliceArray(indices: Collection<Int>): PrimitiveArrayWrapper<Float, FloatArray>

返回一个包含此数组指定索引处元素的新数组.

abstract fun <T : Comparable<Float>> sort(fromIndex: Int = 0, toIndex: Int)

使用快速排序算法对此数组的指定范围内的元素进行排序。

abstract fun <R : Comparable<R>> sortedBy(selector: (Float) -> R?): ListWrapper<Float>

根据给定的选择器函数对元素进行排序，并返回一个包含排序结果的新列表.

sortedByDescending

abstract fun <R : Comparable<R>> sortedByDescending(selector: (Float) -> R?): ListWrapper<Float>

根据给定的选择器函数对元素进行降序排序，并返回一个包含排序结果的新列表.

abstract fun subtract(other: Iterable<Float>): SetWrapper<Float>

返回此数组和给定 Iterable 的差集.

abstract fun take(n: Int): ListWrapper<Float>

返回一个包含数组前 n 个元素的新列表.

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

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

abstract fun takeLast(n: Int): ListWrapper<Float>

返回一个包含数组最后 n 个元素的新列表.

abstract fun takeLastWhile(predicate: (Float) -> Boolean): ListWrapper<Float>

返回一个包含数组元素的新列表，直到满足给定谓词的最后一个元素.

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

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

abstract fun takeWhile(predicate: (Float) -> Boolean): ListWrapper<Float>

返回一个包含数组元素的新列表，直到满足给定谓词的第一个元素.

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

将数组的所有元素添加到给定的集合中.

abstract fun toTypedArray(): ArrayWrapper<Float>

将此包装器转换为 ArrayWrapper.

abstract fun union(other: Iterable<Float>): SetWrapper<Float>

返回此数组和给定 Iterable 的并集.

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

返回一个包含数组元素及其索引的 Iterable.

abstract fun <R, V> zip(other: Iterable<R>, transform: (a: Float, b: R) -> V): ListWrapper<V>

将此数组与给定的 Iterable 组合，并返回一个包含组合结果的新列表.