Types
分类集合，T代表element对象，K代表分类标记值
通过groupingBy获取实例对象
eachCount: Map<K, Int>
获取每种分类的数量eachCountTo(destination: MutableMap<in K, Int>): MutableMap<in K, Int>
获取分类数量并将结果加成到已有计算表destination中aggregate(operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): Map<K, R>
通过一个函数(operation)混合每种分类中每个元素的结果
accumulator为当前分类K的历史混合值，初始值为null，element为当前运算中K分类的某个元素项，first显示element是否当前分类K中的第一个元素aggregateTo(destination: Map<K, R>, operation): Map<K, R>
同上，混合元素并将结果加成到已有计算表destination中fold(initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): Map<K, R>
同aggregate，但每个分类K的首元素的operation运算中，accumulator初始值将由initialValueSelector函数提供（foldTo方法同理）fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Map<K, R>
忽略分类K值的fold版本，每个分类的accumulator均为initialValue（foldTo方法同理）reduce(operation: (key: K, accumulator: S, element: T) -> S): Map<K, S>
同aggregate，但每个分类从第二位元素开始混合，accumulator初始值为当前分类K中的第一个元素值（reduceTo同理）
Functions
增删
- addAll(elements: Iterable<T>): Boolean
MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>)
添加另一个集合的所有元素 - remove(element: T): Boolean
remove(key: K): V?
remove(key: K, value: V): Boolean
removeAll(elements: Collection<T>): Boolean
removeAll(predicate: (T) -> Boolean): Boolean
除去集合中的指定元素（集） - retainAll(elements: Collection<T>): Boolean
retainAll(predicate: (T) -> Boolean): Boolean
当前集合仅保留指定的元素
改
变换
- fill(element: T, fromIndex: Int = 0, toIndex: Int = size)
使用指定值填充Array或MutableList - reverse()
reversed(): List<T>
reversedArray(): Array<T>
翻转元素顺序（并作为新对象返回） - shuffle()
shuffle(random: Random)
shuffled(): List<T>
shuffled(random: Random): List<T>
混淆元素顺序（并作为新对象返回） - sort()
sort(fromIndex: Int = 0, toIndex: Int = size)
sortDescending()
排序数值型或Comparable型集合（或倒序排序） - sort(comparison: (a: T, b: T) -> Int)
通过comparison函数排序 - sortBy(selector: (T) -> R?)
sortByDescending(selector: (T) -> R?)
通过selector函数将集合元素转换为Comparable对象，并进行排序（或倒序排序） - sortWith(comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size)
通过comparator对象进行排序 - sorted(): List<T>
sortedDescending(): List<T>
sortedArray(): Array<T>
sortedArrayDescending(): Array<T>
sortedBy(selector: (T) -> R?): List<T>
sortedByDescending(selector: (T) -> R?): List<T>
sortedWith(comparator: Comparator<in T>): List<T>
sortedArrayWith(comparator: Comparator<in T>): Array<out T>
排序并返回新结果对象
映射转换
- asIterable / asList / asSequence
映射为Iterable、List、Sequence对象 - asReversed
映射为倒序列表（仅用于List、MutableList），原列表数据变动时自动反映到该倒序列表对象 - associate(transform: (T) -> Pair<K, V>): Map<K, V>
associateBy(keySelector: (T) -> K): Map<K, T>
通过函数transform或keySelector，将每个元素关联至一个指定Key值，生成Map对象（associateTo、associateByTo同理） - chunked(size: Int): List<List<T>>
chunked(size: Int, transform: (List<T>) -> R): List<R>
按指定长度切割成多个子列表（仅用于Iterable，可通过transform函数转换结果为特定类型对象（仅用于Iterable） - flatMap(transform: (T) -> Iterable<R>): List<R>
flatMap(transform: (Entry<K, V>) -> Iterable<R>): List<R>
将集合中每个元素通过transform函数映射成每个子集合，并将所有子集合的所有元素合并成单一List序列（flatMapTo同理） - Array<out Array<out T>>.flatten(): List<T>
将元素数组的数组（二维数组）平铺成一维列表 - fold(initial: R, operation: (acc: R, T) -> R): R
foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R
通过operation函数混合（加成）集合中每个元素T，生成中间及返回最终结果R，初始值由initial提供 - foldRight(initial: R, operation: (T, acc: R) -> R): R
foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R
逆序混合 - groupBy(keySelector: (T) -> K): Map<K, List<T>>
groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>
groupingBy(keySelector: (T) -> K): Grouping<T, K>
以keySelector指定的条件分类出集合中同类元素 T，分类标识为 K，可通过valueTransform函数计算元素 T 的映射值（groupByTo同理） - joinTo(buffer: Appendable, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (T) -> CharSequence = null): Appendable
将集合内每个元素通过transform函数转换为字符串，append到buffer对象，字符串分隔符通过separator定义，buffer分别追加prefix和postfix作为元素集合的起始、结束标记，使用limit限制元素数量时，超出限制的部分将以单独一个truncated标记取代，作为最终的集合元素，最后返回buffer对象本身（joinToString相似，使用内建buffer并直接返回String类型） - map(transform: (T) -> R): List<R>
mapTo(destination: C, transform: (T) -> R): C
mapNotNull(transform: (T) -> R?): List<R>
mapNotNullTo(destination: C, transform: (T) -> R?): C
mapIndexed(transform: (index: Int, T) -> R): List<R>
mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C
mapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>
mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C
集合内每个元素通过transform函数计算转换，返回结果列表 - Map<out K, V>.mapKeys(transform: (Entry<K, V>) -> R): Map<R, V>
Map<out K, V>.mapKeysTo(destination: M, transform: (Entry<K, V>) -> R): M
Map<out K, V>.mapValues(transform: (Entry<K, V>) -> R): Map<K, R>
Map<out K, V>.mapValuesTo(destination: M, transform: (Entry<K, V>) -> R): M
Map对象内每个键值对通过transform函数计算转换其Key或Value值，重新组合并返回结果Map - partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>
通过predicate函数，根据集合内每个元素的布尔返回值，切分集合为两个列表对象 - reduce(operation: (accumulator: S, T) -> S): S
reduceIndexed(operation: (index: Int, acc: S, T) -> S): S
通过operation函数，从集合第二个元素T开始混合加成结果S，accumulator初始值为第一个元素值 - reduceRight(operation: (T, acc: S) -> S): S
reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S
逆序混合（集合元素从右侧开始向左侧混合） - toCollection(destination: C): C
集合所有元素添加到指定collection对象并返回 - Entry<K, V>.toPair(): Pair<K, V>
Entry转换至Pair类型 - Map<String, String>.toProperties(): Properties
Map转换至Properties类型 - ByteArray.toString(charset: Charset): String
ByteArray根据指定charset转换为String类型 - toTypedArray(): Array<T>
从某种原始类型Array转换为装箱类型Array - windowed(size: Int, step: Int = 1, partialWindows: Boolean = false): List<List<T>>
windowed(size: Int, step: Int = 1, partialWindows: Boolean = false, transform: (List<T>) -> R): List<R>
返回一个集合的一系列快照组成的列表，每个快照尺寸为size，起始位置为上个快照的起始元素加上step步进数，partialWindows指定最后的快照元素不足于指定size时，是否继续生成小尺寸快照对象，可通过transform函数转换成指定的快照对象类型 - Map<K, V>.withDefault(defaultValue: (key: K) -> V): Map<K, V>
生成一个内含指定默认值计算函数的Map对象 - withIndex(): Iterable<IndexedValue<T>>
withIndex(): Iterator<IndexedValue<T>>
从集合返回一个包含元素下标索引的Iterable对象，通常用于for循环中：for ((index, value) in list.withIndex()) - Iterable<T> zip Iterable<R>: List<Pair<T, R>>
Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>
返回一个以Iterable<T>元素为key，以Iterable<R>元素为value组成的Pair列表，或通过transform函数转换为V类型结果对象的列表 - zipWithNext(): List<Pair<T, T>>
zipWithNext(transform: (a: T, b: T) -> R): List<R>
集合中每个元素均与下一个元素结合（不消耗该元素），组成Pair或R对象，生成结果列表（列表大小与原列表相同） - Iterable<Pair<T, R>>.unzip(): Pair<List<T>, List<R>>
从Pair列表解析出Key列表和Value列表组成的Pair对象
过滤
- copyOf(): Array<T>
copyOf(newSize: Int): Array<T?>
copyOfRange(fromIndex: Int, toIndex: Int): Array<T>
拷贝Array内容到新Array对象，newSize可用于限定拷贝原Array的内容最大数量（小于Array长度） - distinct(): List<T>
过滤掉重复元素 - distinctBy(selector: (T) -> K): List<T>
根据selector函数的返回值过滤重复元素 - drop(n: Int): List<T>、dropLast(n: Int): List<T>
删除集合头、尾的n个元素 - dropWhile(predicate: (T) -> Boolean): List<T>
dropLastWhile(predicate: (T) -> Boolean): List<T>
删除集合头、尾中符合predicate函数指定条件的连续片段（直到遍历到第一个判定为false的元素） - filter(predicate: (T) -> Boolean): List<T>
filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>
过滤集合元素（仅提取predicate函数计算值为true的元素，filterTo、filterIndexedTo同理） - filterIsInstance(): List<R>
filterIsInstance(klass: Class<R>): List<R>
从无类型集合中过滤出对象为返回值R类型的元素（filterIsInstanceTo同理） - filterKeys(predicate: (K) -> Boolean): Map<K, V>
filterValues(predicate: (V) -> Boolean): Map<K, V>
通过Key值、Value值过滤Map元素 - filterNot(predicate: (T) -> Boolean): List<T>
过滤集合元素（仅提取predicate函数计算值为false的元素，filterNotTo同理） - filterNotNull(): List<T>
过滤出非null元素（filterNotNullTo同理） - minusElement(element: T): List<T>
plusElement(element: T): List<T>
返回除去（第一个）指定元素、或增加一个指定元素的列表 - slice(indices: IntRange): List<T>
slice(indices: Iterable<Int>): List<T>
sliceArray(indices: IntRange): Array<T>
sliceArray(indices: Collection<Int>): Array<T>
裁剪出指定范围的子集并返回
集合操作
通常可通过运算符 + - += -= 直接操作集合运算
- Iterable<T>1 intersect Iterable<T>2: Set<T>
两集合相交，取其中共同的对象子集 - Iterable<T>1 subtract Iterable<T>2: Set<T>
返回一个从Iterable1除去Iterable2子集的Set类型结果 - Iterable<T>1 union Iterable<T>2: Set<T>
返回一个Iterable1加上Iterable2的Set类型超集结果
查
判断
- all(predicate: (T) -> Boolean): Boolean
判断一个集合中是否每个元素都符合函数predicate限定的条件 - any(): Boolean
any(predicate: (T) -> Boolean): Boolean
判断一个集合中是否存在至少一个元素（符合函数predicate限定的条件） - contains、containsAll(elements: Collection<T>): Boolean
判断指定集合是否包含特定元素（集） - containsKey、containsValue
判断Map对象中是否包含特定Key、Value - contentDeepEquals、contentDeepHashCode、contentDeepToString
通过Array内容进行迭代比较、计算哈希值或字符串（包括嵌套Array内容） - contentEquals、contentHashCode、contentToString
通过Array内容进行比较、计算哈希值或字符串（不包括嵌套Array内容） - isEmpty / isNotEmpty
判断集合是否为空 - max / min
返回数值型或Comparable型集合的最大、最小元素，不存在时返回null - maxBy(selector: (T) -> R): T?
minBy(selector: (T) -> R): T?
通过selector函数将集合或Map元素转换为Comparable对象，比较并返回最大、最小元素 - maxWith(comparator: Comparator<in T>): T?
minWith(comparator: Comparator<in T>): T?
通过comparator对象比较并返回最大、最小元素 - none(): Boolean
none(predicate: (T) -> Boolean): Boolean
判断一个集合是否为空（或没有一个元素符合函数predicate限定的条件） - Collection<T>?.orEmpty(): Collection<T>
返回非null的调用对象，或返回一个新建的空集合对象 - requireNoNulls()
判断集合是否包含null元素，返回集合本身，或抛出异常
计算
- average(): Double
计算出集合元素的平均值（仅用于数值型Array、Iterable） - count(): Int
count(predicate: (T) -> Boolean): Int
计算出集合的元素数量，predicate函数可用于指定过滤条件 - sum()
计算出集合元素的总和值（仅用于数值型Array、Iterable） - sumBy(selector: (T) -> Int): Int
sumByDouble(selector: (T) -> Double): Double
通过selector函数计算集合元素的总和值
查找提取
- binarySearch(element: T, comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size): Int
通过二分查找算法寻找特定对象element的下标索引位置（要求集合已经过comparator函数排序） - elementAt(index: Int)
elementAtOrElse(index: Int, defaultValue: (Int) -> T)
elementAtOrNull(index: Int)
提取指定下标的元素，超出下标范围时分别抛出异常、返回默认值、返回null - find(predicate: (T) -> Boolean)
findLast(predicate: (T) -> Boolean)
从集合首、尾开始搜索第一个符合predicate条件的元素，不存在时返回null - first() / first(predicate: (T) -> Boolean)
firstOrNull() / firstOrNull(predicate: (T) -> Boolean)
last() / last(predicate: (T) -> Boolean)
lastOrNull() / lastOrNull(predicate: (T) -> Boolean)
从集合中提取第一个或最后一个（符合predicate条件的）元素，不存在时抛出异常，或返回null - getValue(key: K): V
get(key: K): V?
getOrDefault(key: K, defaultValue: V): V
getOrElse(key: K, defaultValue: () -> V): V
getOrPut(key: K, defaultValue: () -> V): V
从Map中获取指定元素值，不存在时分别抛出异常、返回null或defaultValue（或存储该defaultValue值） - getOrNull(index: Int): T?
getOrElse(index: Int, defaultValue: (Int) -> T): T
从集合中获取指定下标的元素值，不存在时分别返回null或defaultValue - indexOf(element: T): Int
lastIndexOf(element: T): Int
indexOfFirst(predicate: (T) -> Boolean): Int
indexOfLast(predicate: (T) -> Boolean): Int
从集合中获取指定元素或首个、最后一个符合predicate条件的元素下标索引，不存在时返回-1 - single(): T
single(predicate: (T) -> Boolean): T
singleOrNull(): T?
singleOrNull(predicate: (T) -> Boolean): T?
返回集合的唯一（符合指定条件的）元素，空集合或存在多于两个元素时抛出异常，或返回null - take(n: Int): List<T>
takeLast(n: Int): List<T>
提取前、后n个元素作为新列表对象返回 - takeWhile(predicate: (T) -> Boolean): List<T>
takeLastWhile(predicate: (T) -> Boolean): List<T>
提取符合predicate函数指定条件的第一个、最后一个元素并作为新列表对象返回
遍历
- forEach(action: (T) -> Unit): Unit
- forEachIndexed(action: (index: Int, T) -> Unit): Unit
- onEach(action: (T) -> Unit): self
- onEachIndexed(action: (index: Int, T) -> Unit): self
- 对每个元素执行action函数运算（并返回对用对象本身）
参考
kotlin.collections.Collections
kotlin.collections._Collections.kt
kotlin.collections._Arrays
