Kotlin Collection

作者: kevinsEegets | 来源:发表于2020-06-08 15:44 被阅读0次

1_K1BGRTUJ8eZTw5E1Qnv2pw.png

https://medium.com/mobile-app-development-publication/kotlin-collection-functions-cheat-sheet-975371a96c4b

`component1`

//返回第1个...第5个值
public inline operator fun <T> List<T>.component1(): T
public inline operator fun <T> List<T>.component2(): T
public inline operator fun <T> List<T>.component3(): T
public inline operator fun <T> List<T>.component4(): T
public inline operator fun <T> List<T>.component5(): T

`contains`

//如果在集合中找到[element]，返回' true '。
public operator fun <@kotlin.internal.OnlyInputTypes T> Iterable<T>.contains(element: T): Boolean

`elementAt`

//获取第几个元素，超出或抛异常
public fun <T> Iterable<T>.elementAt(index: Int): T
public inline fun <T> List<T>.elementAt(index: Int): T

//获取第几个元素，超出执行defaultValue方法
public fun <T> Iterable<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
public inline fun <T> List<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T

//获取第几个元素，超出返回null
public fun <T> Iterable<T>.elementAtOrNull(index: Int): T?
public inline fun <T> List<T>.elementAtOrNull(index: Int): T?

`find`

//找到匹配[predicate]方法的第一个元素并返回，如果没有找到该元素，则返回' null '。
public inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?

//找到匹配[predicate]方法的最后一个元素并返回，如果没有找到该元素，则返回' null '。
public inline fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?
public inline fun <T> List<T>.findLast(predicate: (T) -> Boolean): T?

`first`

//获取集合的第一元素，如果集合为empty则抛异常
kotlinpublic fun <T> Iterable<T>.first(): T
public fun <T> List<T>.first(): T

//获取匹配[predicate]方法的第一个元素并返回，如果没有找到该元素，则抛异常
public inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T

//获取集合的第一元素，如果集合为empty则返回null
public fun <T> Iterable<T>.firstOrNull(): T?
public fun <T> List<T>.firstOrNull(): T?

//找到匹配[predicate]方法的第一个元素并返回，如果没有找到该元素，则返回' null '。
public inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T?

`getOr`

//获取第几个元素，如果越界则调用[defaultValue]函数的结果。
public inline fun <T> List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T

//获取第几个元素，如果越界则返回null
public fun <T> List<T>.getOrNull(index: Int): T?

`indexOf`

//获取和[element]内容相等的第一个索引，如果不匹配，则返回-1。
public fun <@kotlin.internal.OnlyInputTypes T> Iterable<T>.indexOf(element: T): Int
public fun <@kotlin.internal.OnlyInputTypes T> List<T>.indexOf(element: T): Int

//找到匹配[predicate]方法的第一个元素的索引并返回，如果没有找到该元素，则返回-1。
public inline fun <T> Iterable<T>.indexOfFirst(predicate: (T) -> Boolean): Int
public inline fun <T> List<T>.indexOfFirst(predicate: (T) -> Boolean): Int

//找到匹配[predicate]方法的最后一个元素的索引并返回，如果没有找到该元素，则返回-1。
public inline fun <T> Iterable<T>.indexOfLast(predicate: (T) -> Boolean): Int
public inline fun <T> List<T>.indexOfLast(predicate: (T) -> Boolean): Int

`last`

//获取集合的最后一元素，如果集合为empty则抛异常
public fun <T> Iterable<T>.last(): T
public fun <T> List<T>.last(): T

//获取匹配[predicate]方法的最后一个元素并返回，如果没有找到该元素，则抛异常
public inline fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T
public inline fun <T> List<T>.last(predicate: (T) -> Boolean): T

//获取和[element]内容相等的最后一个索引，如果不匹配，则返回-1。
public fun <@kotlin.internal.OnlyInputTypes T> Iterable<T>.lastIndexOf(element: T): Int
public fun <@kotlin.internal.OnlyInputTypes T> List<T>.lastIndexOf(element: T): Int

//获取集合的最后一元素，如果集合为empty则返回null
public fun <T> Iterable<T>.lastOrNull(): T?
public fun <T> List<T>.lastOrNull(): T?

//找到匹配[predicate]方法的最后一个元素并返回，如果没有找到该元素，则返回' null '。
public inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?
public inline fun <T> List<T>.lastOrNull(predicate: (T) -> Boolean): T?

`single`

//返回单个元素，或在集合为空或有多个元素时抛出异常。
public fun <T> Iterable<T>.single(): T
public fun <T> List<T>.single(): T

//返回匹配给定[predicate]的单个元素，如果没有或多于一个匹配元素，则抛出异常。
public inline fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T

//返回单个元素，如果集合为空或有多个元素，则返回' null '。
public fun <T> Iterable<T>.singleOrNull(): T?
public fun <T> List<T>.singleOrNull(): T?

//返回与给定[predicate]匹配的单个元素，如果没有找到元素或找到了多个元素，则返回' null '。
public inline fun <T> Iterable<T>.singleOrNull(predicate: (T) -> Boolean): T?

`drop`

//返回一个去除前n个元素后的列表
public fun <T> Iterable<T>.drop(n: Int): List<T>

//返回一个去除后n个元素后的列表
public fun <T> List<T>.dropLast(n: Int): List<T>

//返回从最后一项起，去掉满足条件的元素，直到不满足条件的一项为止
public inline fun <T> List<T>.dropLastWhile(predicate: (T) -> Boolean): List<T>

//返回从第一项起，去掉满足条件的元素，直到不满足条件的一项为止
public inline fun <T> Iterable<T>.dropWhile(predicate: (T) -> Boolean): List<T>

`filter`

//过滤所有满足条件的元素
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

//过滤所有满足条件的元素，可通过index判断
public inline fun <T> Iterable<T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>
public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C

//过滤所有指定泛型的实例
public inline fun <reified R> Iterable<*>.filterIsInstance(): List<@kotlin.internal.NoInfer R>
public inline fun <reified R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C

//过滤所有不满足条件的元素
public inline fun <T> Iterable<T>.filterNot(predicate: (T) -> Boolean): List<T>

//过滤所有不为null的元素
public fun <T : Any> Iterable<T?>.filterNotNull(): List<T>

//将符合条件的`[predicate]`集合`[destination]`追加到头部
public fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(destination: C): C
public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C
public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C


>>>>>>测试代码(`filterNotNullTo`和`filterNotTo`例子)<<<<<<
 val originalMap = mapOf<String, Int>("key1" to 1, "key2" to 2, "key3" to 3)
        val destinationMap = mutableMapOf<String, Int>("key40" to 40, "key50" to 50)

        val filteredMap = originalMap.filterNotTo(destinationMap) {
            it.value < 3
        }
        println(filteredMap)

        val originalList = mutableListOf<Int>(1, 2, 3)
        val destinationList = mutableListOf<Int>(4, 5, 6)
        val filterList = originalList.filterNotNullTo(destinationList)
        println(filterList)

println------------------------------------
{key40=40, key50=50, key3=3}
[4, 5, 6, 1, 2, 3]

`slice`

//过滤指定[index]范围内的索引中的元素
public fun <T> List<T>.slice(indices: IntRange): List<T>
public fun <T> List<T>.slice(indices: Iterable<Int>): List<T>

`take`

//返回从第一个开始的n个元素
public fun <T> Iterable<T>.take(n: Int): List<T>

//返回从最后一个开始的n个元素
public fun <T> List<T>.takeLast(n: Int): List<T>

//返回从最后一个开始满足条件的元素，只要有一个不满足则不再判断
public inline fun <T> List<T>.takeLastWhile(predicate: (T) -> Boolean): List<T>

//返回从第一个开始满足条件的元素，只要有一个不满足则不再判断
public inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T>

`reverse`

//反向排列集合中的元素,更改原数据
public expect fun <T> MutableList<T>.reverse(): Unit

//创建了一个新数据,将得到的新数据进行反向排列元素集合
public fun <T> Iterable<T>.reversed(): List<T>  

//创建了一个新数据,新数据和原数据排序一致,只是在获取时对新数据进行排序
public fun <T> Iterable<T>.asReversed(): List<T>

`sort`

//将符合条件[selector]函数的集合进行自然排序，对列表中的元素进行排序。
public inline fun <T, R : Comparable<R>> MutableList<T>.sortBy(crossinline selector: (T) -> R?): Unit

//将符合条件[selector]函数的集合进行自然排序，对列表中的元素进行降序排序
public inline fun <T, R : Comparable<R>> MutableList<T>.sortByDescending(crossinline selector: (T) -> R?): Unit

//对列表中的元素按其自然排序顺序，按降序排列。
public fun <T : Comparable<T>> MutableList<T>.sortDescending(): Unit

//上面的sorted形式，sorted会返回新集合，sort是将自己进行排序
public fun <T : Comparable<T>> Iterable<T>.sorted(): List<T>
public inline fun <T, R : Comparable<R>> Iterable<T>.sortedBy(crossinline selector: (T) -> R?): List<T>
public inline fun <T, R : Comparable<R>> Iterable<T>.sortedByDescending(crossinline selector: (T) -> R?): List<T>
public fun <T : Comparable<T>> Iterable<T>.sortedDescending(): List<T>
public fun <T> Iterable<T>.sortedWith(comparator: Comparator<in T>): List<T>

`toXXXArray`

//集合转数组
public fun Collection<Boolean>.toBooleanArray(): BooleanArray
public fun Collection<Byte>.toByteArray(): ByteArray
public fun Collection<Char>.toCharArray(): CharArray
public fun Collection<Double>.toDoubleArray(): DoubleArray
public fun Collection<Int>.toIntArray(): IntArray
public fun Collection<Long>.toLongArray(): LongArray
public fun Collection<Short>.toShortArray(): ShortArray

`associate`

1_HoPU5ZEt7u9d4fKG2PwHdQ.png

//通过指定的条件，把list转换成map
public inline fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>

//通过指定的条件，把list转换成map，只转换key，value为item对象
public inline fun <T, K> Iterable<T>.associateBy(keySelector: (T) -> K): Map<K, T>

//通过指定的条件，把list转换成map，key、value都转换
public inline fun <T, K, V> Iterable<T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>

//上面的实现
public inline fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo(destination: M, keySelector: (T) -> K): M
public inline fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M
public inline fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M

>>>>>>测试代码<<<<<<
val list1 = mutableListOf<Int>(1, 2, 3, 4, 5, 6)
val associate= list1.associateWith {
        it.plus(1)
}
println(associate)  // {1=2, 2=3, 3=4, 4=5, 5=6, 6=7}

`flatMap`

//返回调用[transform]函数转换后的集合。
public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>

public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C

`group`

//返回一个根据[keySelector]函数分组后的map，key为[keySelector]的返回结果，vlue为item的List
public inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>

//返回一个根据[keySelector]函数分组后的map，key为[keySelector]的返回结果，vlue为[valueTransform]值的List
public inline fun <T, K, V> Iterable<T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>

//实现
public inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K): M
public inline fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K, valueTransform: (T) -> V): M

//此API可用于按键（key）分组，同时折叠（fold）每个组。 例如，它可以用于计算从每个字母开始的单词数： words.groupingBy { it.first() }.eachCount()
public inline fun <T, K> Iterable<T>.groupingBy(crossinline keySelector: (T) -> K): Grouping<T, K>

`map`

通过[transform]转换成新集合
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

//通过[transform]转换成新集合，可通过index判断
public inline fun <T, R> Iterable<T>.mapIndexed(transform: (index: Int, T) -> R): List<R>

//通过[transform]转换成可null集合，可通过index判断
public inline fun <T, R : Any> Iterable<T>.mapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>

//实现
public inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C
public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C

//通过[transform]转换成可null集合
public inline fun <T, R : Any> Iterable<T>.mapNotNull(transform: (T) -> R?): List<R>

//实现
public inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(destination: C, transform: (T) -> R?): C
public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C

`distinct`

//返回一个只包含不同元素的数组（去重）
public fun <T> Iterable<T>.distinct(): List<T>

//返回集合元素执行指定条件后，不同元素的数组（去重）
public inline fun <T, K> Iterable<T>.distinctBy(selector: (T) -> K): List<T>

`any`

//如果集合中至少有一个元素，则返回 true 。
public fun <T> Iterable<T>.any(): Boolean

//如果至少有一个元素与判断条件相符，则 返回true
public inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean

`count`

//返回集合的数量
public fun <T> Iterable<T>.count(): Int
public inline fun <T> Collection<T>.count(): Int

//返回与判断条件相符的元素个数
public inline fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int

`operation`

//从[initial]值开始循环每个元素并累计到[operation]参数里的accumulator并返回
public inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R

//从[initial]值开始循环每个元素并累计到[operation]参数里的accumulator并返回，可通过index判断
public inline fun <T, R> Iterable<T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R

//从[initial]值开始倒叙循环每个元素并累计到[operation]参数里的accumulator并返回
public inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, acc: R) -> R): R

//从[initial]值开始倒叙循环每个元素并累计到[operation]参数里的accumulator并返回，可通过index判断
public inline fun <T, R> List<T>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R

`forEach`

//循环迭代每一项并执行[action]操作
public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit

//循环迭代每一项并执行[action]操作，可通过index判断
public inline fun <T> Iterable<T>.forEachIndexed(action: (index: Int, T) -> Unit): Unit

`max`

//返回最大值，如果没有元素，则为“null”。
public fun Iterable<Double>.max(): Double?
public fun Iterable<Float>.max(): Float?
public fun <T : Comparable<T>> Iterable<T>.max(): T?

//返回指定[selector]规则的最大值的item元素中第一个（不是规则后的最大值），如果没有元素，则返回null
public inline fun <T, R : Comparable<R>> Iterable<T>.maxBy(selector: (T) -> R): T?

//根据提供的[comparator]返回值最大的第一个元素，如果没有元素，则返回' null '。
public fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T?

`min`

//返回最小值，如果没有元素，则为“null”。
public fun Iterable<Double>.min(): Double?
public fun Iterable<Float>.min(): Float?
public fun <T : Comparable<T>> Iterable<T>.min(): T?
public inline fun <T, R : Comparable<R>> Iterable<T>.minBy(selector: (T) -> R): T?
public fun <T> Iterable<T>.minWith(comparator: Comparator<in T>): T?

`reduce`

//循环每个元素并累计到[operation]参数里的accumulator并返回，与fold功能一样。但是，没有初始值。
public inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S
public inline fun <S, T : S> Iterable<T>.reduceIndexed(operation: (index: Int, acc: S, T) -> S): S

//倒叙循环每个元素并累计到[operation]参数里的accumulator并返回
public inline fun <S, T : S> List<T>.reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S

`requireNoNulls`

//需要全部不为null，如果有null则抛出[IllegalArgumentException]
public fun <T : Any> Iterable<T?>.requireNoNulls(): Iterable<T>
public fun <T : Any> List<T?>.requireNoNulls(): List<T>

`chunked`

//将此集合分割为一个列表集合存储列表，每个列表都不超过给定的[size]。
public fun <T> Iterable<T>.chunked(size: Int): List<List<T>>
 
//将此集合分割为一个列表集合存储列表，每个列表都不超过给定的[size]。[transform]可用于转换
public fun <T, R> Iterable<T>.chunked(size: Int, transform: (List<T>) -> R): List<R>

`zip`

///返回一个列表，该列表由两个集合中相同index元素建立的元素对。这个列表长度为最短集合的长度。
public infix fun <T, R> Iterable<T>.zip(other: Array<out R>): List<Pair<T, R>>

///使用应用于每一对元素的[transform]函数，返回从' this '集合的元素和具有相同索引的[other]数组构建的值列表。
public inline fun <T, R, V> Iterable<T>.zip(other: Array<out R>, transform: (a: T, b: R) -> V): List<V>
public infix fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>>
public inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>

//返回一个集合包含每个相邻元素Pair的列表。如果这个集合包含的元素少于两个，返回的列表为空。
public fun <T> Iterable<T>.zipWithNext(): List<Pair<T, T>>

//返回一个集合包含每个相邻元素[transform]转换后R的列表。如果这个集合包含的元素少于两个，返回的列表为空。
public inline fun <T, R> Iterable<T>.zipWithNext(transform: (a: T, b: T) -> R): List<R>

`join`

//拼接字符串，[buffer]要拼接到哪，[separator]分隔符，[prefix]前缀，[postfix]后缀，[limit]限制显示多少，[truncated]超过限制显示的内容，[transform]转换
public fun <T, A : Appendable> Iterable<T>.joinTo(buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): A

//同joinTo，但是给joinTo方法中buffer赋值为StringBuilder
public fun <T> Iterable<T>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): String

`sum`


//返回累加[selector]返回值的和。
public inline fun <T> Iterable<T>.sumBy(selector: (T) -> Int): Int
public inline fun <T> Iterable<T>.sumByDouble(selector: (T) -> Double): Double

`minus`


//减去(过滤)第一个出现的[element]元素
public operator fun <T> Iterable<T>.minus(element: T): List<T>

//减去(过滤)[elements]集合中包含的元素
public operator fun <T> Iterable<T>.minus(elements: Array<out T>): List<T>
public operator fun <T> Iterable<T>.minus(elements: Iterable<T>): List<T>
public operator fun <T> Iterable<T>.minus(elements: Sequence<T>): List<T>

//同minus
public inline fun <T> Iterable<T>.minusElement(element: T): List<T>

`plus`

//返回一个包含原集合和给定集合中所有元素的集合。也可以使用+操作符
public operator fun <T> Iterable<T>.plus(element: T): List<T>
public operator fun <T> Collection<T>.plus(element: T): List<T>
public operator fun <T> Iterable<T>.plus(elements: Array<out T>): List<T>
public operator fun <T> Collection<T>.plus(elements: Array<out T>): List<T>
public operator fun <T> Iterable<T>.plus(elements: Iterable<T>): List<T>
public operator fun <T> Collection<T>.plus(elements: Iterable<T>): List<T>
public operator fun <T> Iterable<T>.plus(elements: Sequence<T>): List<T>
public operator fun <T> Collection<T>.plus(elements: Sequence<T>): List<T>
//同plus
public inline fun <T> Iterable<T>.plusElement(element: T): List<T>
public inline fun <T> Collection<T>.plusElement(element: T): List<T>

`asIterable`

//以[Iterable]的形式返回这个集合。
public inline fun <T> Iterable<T>.asIterable(): Iterable<T>

`asSequence`

//创建一个[Sequence]实例，该实例包装了迭代时返回元素的原始集合。
public fun <T> Iterable<T>.asSequence(): Sequence<T>

`windowed`

//将一个集合分为多个，待研究
public fun <T> Iterable<T>.windowed(size: Int, step: Int = 1, partialWindows: Boolean = false): List<List<T>>
public fun <T, R> Iterable<T>.windowed(size: Int, step: Int = 1, partialWindows: Boolean = false, transform: (List<T>) -> R): List<R>

`partition`

//把一个集合分割成2个。第一个集合是所有符合[predicate]条件的，第二个集合是所有不符合[predicate]条件的集合
public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>

`withIndex`

//为原始集合的每个元素返回[IndexedValue]的惰性[Iterable]。
public fun <T> Iterable<T>.withIndex(): Iterable<IndexedValue<T>>

`intersect`

//两个集合的交集，即公共部分
public infix fun <T> Iterable<T>.intersect(other: Iterable<T>): Set<T>

`subtract`

//两个集合的相减，即包含此集合所包含但不包含指定集合的所有元素。
public infix fun <T> Iterable<T>.subtract(other: Iterable<T>): Set<T>

`union`

//两个集合的相加，即包含来自两个集合的所有不同元素的集合。
public infix fun <T> Iterable<T>.union(other: Iterable<T>): Set<T>

`all`

//如果全部元素与判断条件相符，则 返回true
public inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean

`none`

//如果集合中没有元素，返回“true”。
public fun <T> Iterable<T>.none(): Boolean

//如果没有匹配[predicate]的元素，则返回' true '。和any相反
public inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean

`所有元素添加到[destination]集合。`

//所有元素添加到[destination]集合。
public fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(destination: C): C

`返回包含所有元素的[XXX]集合`

//返回包含所有元素的[XXX]集合。
public fun <T> Iterable<T>.toHashSet(): HashSet<T>
public fun <T> Iterable<T>.toList(): List<T>
public fun <T> Iterable<T>.toMutableList(): MutableList<T>
public fun <T> Collection<T>.toMutableList(): MutableList<T>
public fun <T> Iterable<T>.toSet(): Set<T>

`返回集合中元素的平均值`

public fun Iterable<Byte>.average(): Double
public fun Iterable<Short>.average(): Double
public fun Iterable<Int>.average(): Double
public fun Iterable<Long>.average(): Double
public fun Iterable<Float>.average(): Double
public fun Iterable<Double>.average(): Double

`返回集合中元素的和`

public fun Iterable<Byte>.sum(): Int
public fun Iterable<Short>.sum(): Int
public fun Iterable<Int>.sum(): Int
public fun Iterable<Long>.sum(): Long
public fun Iterable<Float>.sum(): Float
public fun Iterable<Double>.sum(): Double

Kotlin Collection

https://medium.com/mobile-app-development-publication/kotlin-collection-functions-cheat-sheet-975371a96c4b

component1

contains

elementAt

find

first

getOr

indexOf

last

single

drop

filter

slice

take

reverse

sort

toXXXArray

associate

flatMap

group

map

distinct

any

count

operation

forEach

max

min

reduce

requireNoNulls

chunked

zip

join

sum

minus

plus

asIterable

asSequence

windowed

partition

withIndex

intersect

subtract

union

all

none

所有元素添加到[destination]集合。

返回包含所有元素的[XXX]集合

返回集合中元素的平均值

返回集合中元素的和

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

`component1`

`contains`

`elementAt`

`find`

`first`

`getOr`

`indexOf`

`last`

`single`

`drop`

`filter`

`slice`

`take`

`reverse`

`sort`

`toXXXArray`

`associate`

`flatMap`

`group`

`map`

`distinct`

`any`

`count`

`operation`

`forEach`

`max`

`min`

`reduce`

`requireNoNulls`

`chunked`

`zip`

`join`

`sum`

`minus`

`plus`

`asIterable`

`asSequence`

`windowed`

`partition`

`withIndex`

`intersect`

`subtract`

`union`

`all`

`none`

`所有元素添加到[destination]集合。`

`返回包含所有元素的[XXX]集合`

`返回集合中元素的平均值`

`返回集合中元素的和`