一、Array（数组）
创建方法
| 方法 | 说明 | 示例 |
|---|
arrayOf() | 创建数组 | val arr = arrayOf(1, 2, 3) |
arrayOfNulls() | 创建指定大小的空数组 | val nullArr = arrayOfNulls<String>(3) |
Array() 构造函数 | 通过函数初始化 | val squares = Array(5) { i -> i * i } |
常用方法
| 方法 | 说明 | 示例 |
|---|
size | 获取数组大小 | arr.size // 3 |
get(index) | 获取指定位置元素 | arr.get(0) // 1 |
set(index, value) | 设置指定位置元素 | arr.set(1, 5) |
contains(element) | 检查是否包含元素 | arr.contains(2) // true |
indexOf(element) | 获取元素索引 | arr.indexOf(3) // 2 |
forEach { } | 遍历数组 | arr.forEach { println(it) } |
map { } | 转换数组 | arr.map { it * 2 } // [2, 4, 6] |
filter { } | 过滤元素 | arr.filter { it > 1 } // [2, 3] |
sort() | 排序（可变数组） | arr.sort() |
sliceArray(indices) | 切片 | arr.sliceArray(0..1) // [1, 2] |
joinToString() | 连接为字符串 | arr.joinToString("-") // "1-2-3" |
二、List（列表）
创建方法
| 方法 | 说明 | 示例 |
|---|
listOf() | 创建不可变列表 | val list = listOf("a", "b", "c") |
mutableListOf() | 创建可变列表 | val mList = mutableListOf(1, 2, 3) |
emptyList() | 创建空列表 | val empty = emptyList<Int>() |
List(3) { "TZ" } | 创建3个相同的元素TZ | List(3) { "TZ" } // "a, b, c" |
通用方法（不可变/可变）
| 方法 | 说明 | 示例 |
|---|
size | 获取列表大小 | list.size // 3 |
get(index) | 获取指定位置元素 | list[1] // "b" |
indexOf(element) | 获取元素索引 | list.indexOf("c") // 2 |
contains(element) | 检查是否包含元素 | list.contains("a") // true |
subList(from, to) | 获取子列表 | list.subList(0, 2) // ["a", "b"] |
forEach { } | 遍历列表 | list.forEach { print(it) } |
map { } | 转换列表 | list.map { it.uppercase() } // [A, B, C] |
filter { } | 过滤元素 | list.filter { it != "b" } // ["a", "c"] |
any { } | 检查是否有元素满足条件 | list.any { it == "b" } // true |
all { } | 检查所有元素满足条件 | list.all { it.length == 1 } // true |
none { } | 检查没有元素满足条件 | list.none { it == "d" } // true |
first() | 获取第一个元素 | list.first() // "a" |
last() | 获取最后一个元素 | list.last() // "c" |
sorted() | 排序（返回新列表） | list.sorted() // 自然顺序 |
reversed() | 反转列表 | list.reversed() // ["c", "b", "a"] |
joinToString() | 连接为字符串 | list.joinToString() // "a, b, c" |
listOfNotNull(element) | 自动去除所有null元素，再创建只读列表 | val array = arrayOf("A", null, "C");
val list: List<String> = listOfNotNull(*array) |
可变列表特有方法
| 方法 | 说明 | 示例 |
|---|
add(element) | 添加元素 | mList.add(4) |
add(index, element) | 在指定位置添加元素 | mList.add(0, 0) |
remove(element) | 移除元素 | mList.remove(2) |
removeAt(index) | 移除指定位置元素 | mList.removeAt(0) |
set(index, element) | 修改指定位置元素 | mList[1] = 10 |
clear() | 清空列表 | mList.clear() |
sort() | 原地排序 | mList.sort() |
shuffle() | 随机打乱 | mList.shuffle() |
三、Set（集合）
创建方法
| 方法 | 说明 | 示例 |
|---|
setOf() | 创建不可变集合 | val set = setOf(1, 2, 3) |
mutableSetOf() | 创建可变集合 | val mSet = mutableSetOf("a", "b") |
hashSetOf() | 创建HashSet | val hashSet = hashSetOf(1.0, 2.0) |
sortedSetOf() | 创建SortedSet | val sortedSet = sortedSetOf(3, 1, 2) |
通用方法（不可变/可变）
| 方法 | 说明 | 示例 |
|---|
size | 获取集合大小 | set.size // 3 |
contains(element) | 检查是否包含元素 | set.contains(2) // true |
isEmpty() | 检查是否为空 | set.isEmpty() // false |
isNotEmpty() | 检查是否非空 | set.isNotEmpty() // true |
forEach { } | 遍历集合 | set.forEach { println(it) } |
filter { } | 过滤元素 | set.filter { it > 1 } // [2, 3] |
map { } | 转换集合 | set.map { it * 2 } // [2, 4, 6] |
any { } | 检查是否有元素满足条件 | set.any { it % 2 == 0 } // true |
all { } | 检查所有元素满足条件 | set.all { it < 5 } // true |
union(other) | 并集 | set.union(setOf(3, 4)) // [1,2,3,4] |
intersect(other) | 交集 | set.intersect(setOf(2,3)) // [2,3] |
minus(other) | 差集 | set.minus(setOf(3)) // [1,2] |
可变集合特有方法
| 方法 | 说明 | 示例 |
|---|
add(element) | 添加元素 | mSet.add("c") |
remove(element) | 移除元素 | mSet.remove("a") |
clear() | 清空集合 | mSet.clear() |
retainAll(other) | 保留交集 | mSet.retainAll(setOf("b", "c")) |
addAll(other) | 添加多个元素 | mSet.addAll(listOf("d", "e")) |
四、Map（映射）
创建方法
| 方法 | 说明 | 示例 |
|---|
mapOf() | 创建不可变映射 | val map = mapOf(1 to "a", 2 to "b") |
mutableMapOf() | 创建可变映射 | val mMap = mutableMapOf("k1" to 1, "k2" to 2) |
hashMapOf() | 创建HashMap | val hashMap = hashMapOf(1 to "x", 2 to "y") |
linkedMapOf() | 创建LinkedHashMap | val linkedMap = linkedMapOf("a" to 1, "b" to 2) |
通用方法（不可变/可变）
| 方法 | 说明 | 示例 |
|---|
size | 获取映射大小 | map.size // 2 |
keys | 获取所有键 | map.keys // [1, 2] |
values | 获取所有值 | map.values // ["a", "b"] |
entries | 获取所有键值对 | map.entries |
isEmpty() | 检查是否为空 | map.isEmpty() // false |
containsKey(key) | 检查是否包含键 | map.containsKey(1) // true |
containsValue(value) | 检查是否包含值 | map.containsValue("b") // true |
get(key) | 获取键对应值 | map[2] // "b" |
getOrDefault(key, default) | 安全获取值 | map.getOrDefault(3, "c") // "c" |
forEach { } | 遍历映射 | map.forEach { k, v -> println("$k: $v") } |
filter { } | 过滤键值对 | map.filter { (k, v) -> k > 1 && v.startsWith("b") } |
mapKeys { } | 转换键 | map.mapKeys { it.key * 2 } // {2="a", 4="b"} |
mapValues { } | 转换值 | map.mapValues { it.value.uppercase() } // {1="A", 2="B"} |
any { } | 检查是否有键值对满足条件 | map.any { it.key == 2 } // true |
all { } | 检查所有键值对满足条件 | map.all { it.value is String } // true |
可变映射特有方法
| 方法 | 说明 | 示例 |
|---|
put(key, value) | 添加/更新键值对 | mMap.put("k3", 3) |
remove(key) | 移除键值对 | mMap.remove("k1") |
clear() | 清空映射 | mMap.clear() |
putAll(other) | 添加多个键值对 | mMap.putAll(mapOf("k4" to 4, "k5" to 5)) |
getOrPut(key) { value } | 获取或创建值 | mMap.getOrPut("new") { 100 } |
compute(key) { } | 计算新值 | mMap.compute("k1") { k, v -> v?.times(2) } |
五、通用集合方法
以下方法适用于所有集合类型（Array, List, Set, Map）：
| 方法 | 说明 | 示例 |
|---|
isEmpty() | 检查是否为空 | list.isEmpty() |
isNotEmpty() | 检查是否非空 | set.isNotEmpty() |
count() | 获取元素数量 | map.count() |
count { predicate } | 统计满足条件的元素 | arr.count { it > 5 } |
first() | 获取第一个元素 | list.first() |
first { predicate } | 获取第一个满足条件的元素 | set.first { it % 2 == 0 } |
last() | 获取最后一个元素 | list.last() |
last { predicate } | 获取最后一个满足条件的元素 | arr.last { it < 10 } |
maxOrNull() | 获取最大值 | listOf(1,5,2).maxOrNull() // 5 |
minOrNull() | 获取最小值 | setOf(3,1,4).minOrNull() // 1 |
sum() | 求和（数值集合） | listOf(1,2,3).sum() // 6 |
average() | 求平均值 | arrayOf(1.0, 2.0, 3.0).average() // 2.0 |
distinct() | 去重 | listOf(1,2,2,3).distinct() // [1,2,3] |
groupBy { } | 按条件分组 | list.groupBy { it.length } |
associateBy { } | 创建映射 | list.associateBy { it.id } |
partition { } | 分区 | val (even, odd) = list.partition { it % 2 == 0 } |
zip(other) | 合并两个集合 | listOf(1,2).zip(listOf("a","b")) // [(1,"a"), (2,"b")] |
take(n) | 取前n个元素 | list.take(2) |
drop(n) | 丢弃前n个元素 | set.drop(1) |
chunked(size) | 分块 | list.chunked(3) |
windowed(size) | 滑动窗口 | list.windowed(2) |
fold(initial) { } | 累积操作 | list.fold(0) { acc, i -> acc + i } |
reduce { } | 累积操作（无初始值） | array.reduce { acc, i -> acc * i } |
filterIsInstance<T>() | 过滤集合，返回指定类型T的元素组成的列表 | list.filterIsInstance<String>() |
filterIsInstanceTo(destination) | 将集合中指定类型T的元素添加到目标集合destination | list.filterIsInstanceTo(destList) |
