2.Kotlin 集合 List 所有方法

Kotlin List 所有方法(按功能分类)

一、基础属性与构造
方法/属性 说明 示例
size: Int 集合元素数量 val list = listOf(1, 2, 3) list.size // 3
indices: IntRange 有效索引范围(0 until size) val list = listOf(1, 2, 3) list.indices // 0..2
lastIndex: Int 最后一个元素的索引(size - 1) val list = listOf(1, 2, 3) list.lastIndex // 2
isEmpty(): Boolean 判断是否为空集合 listOf<Int>().isEmpty() // true
isNotEmpty(): Boolean 判断是否为非空集合 listOf(1).isNotEmpty() // true
二、元素访问
方法 说明 示例
get(index: Int): E 获取指定索引元素(可简写为 list[index] val list = listOf("a", "b") list.get(0) // "a" list[0] // 简写形式
getOrNull(index: Int): E? 获取元素,越界返回 null val list = listOf(1, 2, 3) list.getOrNull(5) // null
getOrElse(index: Int, defaultValue: (Int) -> E): E 越界时返回默认值 val list = listOf(1, 2, 3) list.getOrElse(5) { 0 } // 0
first(): E 获取首个元素(空集合抛异常) listOf(1, 2).first() // 1
firstOrNull(): E? 获取首个元素(空集合返回 null) listOf<Int>().firstOrNull() // null
last(): E 获取最后一个元素(空集合抛异常) listOf(1, 2).last() // 2
lastOrNull(): E? 获取最后一个元素(空集合返回 null) listOf<Int>().lastOrNull() // null
三、迭代与遍历
方法 说明 示例
iterator(): Iterator<E> 返回迭代器 val list = listOf(1, 2, 3) val it = list.iterator() while (it.hasNext()) println(it.next())
listIterator(): ListIterator<E> 返回列表迭代器(支持双向遍历) val list = listOf(1, 2, 3) val it = list.listIterator() it.next() // 1 it.previous() // 1
listIterator(index: Int): ListIterator<E> 从指定索引开始的列表迭代器 val list = listOf(1, 2, 3) val it = list.listIterator(1) it.next() // 2
forEach(action: (E) -> Unit) 遍历所有元素 val list = listOf(1, 2, 3) list.forEach { print(it * 2) } // 输出: 246
forEachIndexed(action: (Int, E) -> Unit) 带索引的遍历 val list = listOf(1, 2, 3) list.forEachIndexed { i, v -> println("索引 $i: $v") }
withIndex(): Iterable<IndexedValue<E>> 返回索引-值对迭代器 val list = listOf(1, 2, 3) for ((i, v) in list.withIndex()) { println("$i -> $v") }
四、转换操作
方法 说明 示例
toList(): List<E> 转换为不可变列表(本身为List时返回自身) val list = listOf(1, 2) list.toList() // [1, 2]
toMutableList(): MutableList<E> 转换为可变列表 val list = listOf(1, 2) val mutableList = list.toMutableList() mutableList.add(3) // [1, 2, 3]
toSet(): Set<E> 转换为集合(去重) val list = listOf(1, 2, 2, 3) list.toSet() // [1, 2, 3]
toTypedArray(): Array<E> 转换为数组 val list = listOf(1, 2, 3) list.toTypedArray() // [1, 2, 3](数组)
plus(element: E): List<E> 添加单个元素并返回新列表 val list = listOf(1, 2) list.plus(3) // [1, 2, 3]
plus(elements: Collection<E>): List<E> 合并集合并返回新列表 val list = listOf(1, 2) list.plus(listOf(3, 4)) // [1, 2, 3, 4]
plus(elements: Array<out E>): List<E> 合并数组并返回新列表 val list = listOf(1, 2) list.plus(arrayOf(3, 4)) // [1, 2, 3, 4]
map(transform: (E) -> R): List<R> 元素转换 val list = listOf(1, 2, 3) list.map { it * 2 } // [2, 4, 6]
mapIndexed(transform: (Int, E) -> R): List<R> 带索引的元素转换 val list = listOf(1, 2, 3) list.mapIndexed { i, v -> i + v } // [1, 3, 5]
flatMap(transform: (E) -> Iterable<R>): List<R> 扁平转换 val list = listOf(listOf(1), listOf(2, 3)) list.flatMap { it } // [1, 2, 3]
filter(transform: (E) -> Boolean): List<E> 过滤元素并返回新列表 val list = listOf(1, 2, 3, 4) list.filter { it % 2 == 0 } // [2, 4]
五、排序操作
方法 说明 示例
sorted(): List<E> 返回升序排序的新列表(元素需实现Comparable) val list = listOf(3, 1, 2) list.sorted() // [1, 2, 3]
sortedDescending(): List<E> 返回降序排序的新列表 val list = listOf(3, 1, 2) list.sortedDescending() // [3, 2, 1]
sortedBy(selector: (E) -> Comparable<*>?): List<E> 按选择器结果升序排序 val list = listOf("apple", "banana") list.sortedBy { it.length } // [apple, banana]
sortedByDescending(selector: (E) -> Comparable<*>?): List<E> 按选择器结果降序排序 val list = listOf("apple", "banana") list.sortedByDescending { it.length } // [banana, apple]
sortedWith(comparator: Comparator<in E>): List<E> 按自定义比较器排序 val list = listOf("b", "a", "c") list.sortedWith(compareBy { it }) // [a, b, c]
reversed(): List<E> 返回元素反转的新列表 val list = listOf(1, 2, 3) list.reversed() // [3, 2, 1]
asReversed(): List<E> 返回反转视图(原列表变化时同步变化) val mutableList = mutableListOf(1, 2, 3) val reversed = mutableList.asReversed() mutableList.add(4) reversed // [4, 3, 2, 1]
六、查找与过滤
方法 说明 示例
contains(element: E): Boolean 判断是否包含指定元素 val list = listOf(1, 2, 3) list.contains(2) // true
containsAll(elements: Collection<E>): Boolean 判断是否包含所有元素 val list = listOf(1, 2, 3) list.containsAll(listOf(1, 3)) // true
indexOf(element: E): Int 元素首次出现的索引(无则-1) val list = listOf(1, 2, 2, 3) list.indexOf(2) // 1
lastIndexOf(element: E): Int 元素最后出现的索引(无则-1) val list = listOf(1, 2, 2, 3) list.lastIndexOf(2) // 2
indexOfFirst(predicate: (E) -> Boolean): Int 首个满足条件元素的索引 val list = listOf(1, 3, 5, 4) list.indexOfFirst { it % 2 == 0 } // 3
indexOfLast(predicate: (E) -> Boolean): Int 最后满足条件元素的索引 val list = listOf(1, 4, 3, 4) list.indexOfLast { it % 2 == 0 } // 3
first(predicate: (E) -> Boolean): E 首个满足条件的元素(无则抛异常) val list = listOf(1, 2, 3) list.first { it > 1 } // 2
firstOrNull(predicate: (E) -> Boolean): E? 首个满足条件的元素(无则null) val list = listOf(1, 3, 5) list.firstOrNull { it % 2 == 0 } // null
last(predicate: (E) -> Boolean): E 最后满足条件的元素(无则抛异常) val list = listOf(1, 2, 3) list.last { it > 1 } // 3
lastOrNull(predicate: (E) -> Boolean): E? 最后满足条件的元素(无则null) val list = listOf(1, 3, 5) list.lastOrNull { it % 2 == 0 } // null
single(): E 唯一元素(元素数不为1则抛异常) listOf(5).single() // 5
singleOrNull(): E? 唯一元素(元素数不为1则null) listOf(1, 2).singleOrNull() // null
single(predicate: (E) -> Boolean): E 唯一满足条件的元素(不满足则抛异常) listOf(1, 2, 3).single { it == 2 } // 2
singleOrNull(predicate: (E) -> Boolean): E? 唯一满足条件的元素(不满足则null) listOf(1, 2, 3, 4).singleOrNull { it % 2 == 0 } // null
filterNot(predicate: (E) -> Boolean): List<E> 过滤不满足条件的元素 val list = listOf(1, 2, 3, 4) list.filterNot { it % 2 == 0 } // [1, 3]
filterIsInstance<T>(): List<T> 过滤指定类型的元素 val list = listOf(1, "a", 2, "b") list.filterIsInstance<Int>() // [1, 2]
filterNotNull(): List<E> 过滤非空元素(适用于 nullable 类型) val list = listOf(1, null, 3) list.filterNotNull() // [1, 3]
find(predicate: (E) -> Boolean): E? 等同于 firstOrNull(predicate) val list = listOf(1, 2, 3) list.find { it > 1 } // 2
findLast(predicate: (E) -> Boolean): E? 等同于 lastOrNull(predicate) val list = listOf(1, 2, 3) list.findLast { it > 1 } // 3
binarySearch(element: E): Int 二分查找元素索引(需先排序) val list = listOf(1, 2, 3, 4) list.binarySearch(3) // 2
七、统计与判断
方法 说明 示例
count(): Int 元素总数(等同于 size) listOf(1, 2, 3).count() // 3
count(predicate: (E) -> Boolean): Int 满足条件的元素数 listOf(1, 2, 3).count { it > 1 } // 2
sum(): E 元素总和(数值类型) listOf(1, 2, 3).sum() // 6
sumBy(selector: (E) -> Int): Int 按选择器计算总和 listOf("a", "ab", "abc").sumBy { it.length } // 6
sumByDouble(selector: (E) -> Double): Double 按选择器计算浮点总和 listOf(1.5, 2.5).sumByDouble { it } // 4.0
average(): Double 平均值(数值类型) listOf(1, 2, 3).average() // 2.0
maxOrNull(): E? 最大值 listOf(1, 3, 2).maxOrNull() // 3
minOrNull(): E? 最小值 listOf(1, 3, 2).minOrNull() // 1
maxByOrNull(selector: (E) -> Comparable<*>?): E? 按选择器取最大值元素 listOf("a", "ab").maxByOrNull { it.length } // "ab"
minByOrNull(selector: (E) -> Comparable<*>?): E? 按选择器取最小值元素 listOf("a", "ab").minByOrNull { it.length } // "a"
all(predicate: (E) -> Boolean): Boolean 是否所有元素满足条件 listOf(2, 4, 6).all { it % 2 == 0 } // true
any(predicate: (E) -> Boolean): Boolean 是否存在满足条件的元素 listOf(1, 3, 4).any { it % 2 == 0 } // true
none(predicate: (E) -> Boolean): Boolean 是否无元素满足条件 listOf(1, 3).none { it % 2 == 0 } // true
八、集合操作
方法 说明 示例
distinct(): List<E> 去重并返回新列表 listOf(1, 2, 2, 3).distinct() // [1, 2, 3]
distinctBy(selector: (E) -> Any?): List<E> 按选择器去重 listOf("a", "A", "b").distinctBy { it.lowercase() } // ["a", "b"]
intersect(other: Collection<E>): Set<E> 计算与另一个集合的交集 listOf(1, 2).intersect(listOf(2, 3)) // [2]
union(other: Collection<E>): Set<E> 计算与另一个集合的并集 listOf(1, 2).union(listOf(2, 3)) // [1, 2, 3]
subtract(other: Collection<E>): Set<E> 计算与另一个集合的差集 listOf(1, 2).subtract(listOf(2, 3)) // [1]
drop(n: Int): List<E> 丢弃前n个元素 listOf(1, 2, 3).drop(1) // [2, 3]
dropLast(n: Int): List<E> 丢弃后n个元素 listOf(1, 2, 3).dropLast(1) // [1, 2]
dropWhile(predicate: (E) -> Boolean): List<E> 丢弃满足条件的前缀元素 listOf(1, 2, 3).dropWhile { it < 2 } // [2, 3]
dropLastWhile(predicate: (E) -> Boolean): List<E> 丢弃满足条件的后缀元素 listOf(1, 2, 3).dropLastWhile { it > 2 } // [1, 2]
take(n: Int): List<E> 获取前n个元素 listOf(1, 2, 3).take(2) // [1, 2]
takeLast(n: Int): List<E> 获取后n个元素 listOf(1, 2, 3).takeLast(2) // [2, 3]
takeWhile(predicate: (E) -> Boolean): List<E> 获取满足条件的前缀元素 listOf(1, 2, 3).takeWhile { it < 3 } // [1, 2]
takeLastWhile(predicate: (E) -> Boolean): List<E> 获取满足条件的后缀元素 listOf(1, 2, 3).takeLastWhile { it > 1 } // [2, 3]
chunked(size: Int): List<List<E>> 按指定大小拆分列表 listOf(1, 2, 3, 4).chunked(2) // [[1,2], [3,4]]
windowed(size: Int): List<List<E>> 滑动窗口(连续子列表) listOf(1, 2, 3, 4).windowed(2) // [[1,2], [2,3], [3,4]]
zip(other: Iterable<R>): List<Pair<E, R>> 与另一个集合拉链操作 listOf(1, 2).zip(listOf("a", "b")) // [(1,"a"), (2,"b")]
unzip(): Pair<List<A>, List<B>> 拆分 Pair 列表为两个列表 listOf(1 to "a", 2 to "b").unzip() // ([1,2], ["a","b"])
九、聚合与折叠
方法 说明 示例
fold(initial: R, operation: (acc: R, E) -> R): R 从初始值开始折叠操作 listOf(1, 2).fold(0) { acc, v -> acc + v } // 3
foldRight(initial: R, operation: (E, acc: R) -> R): R 从右向左折叠 listOf(1, 2).foldRight(0) { v, acc -> v - acc } // 1
reduce(operation: (acc: E, E) -> E): E 从第一个元素开始缩减 listOf(1, 2, 3).reduce { a, b -> a + b } // 6
reduceRight(operation: (E, acc: E) -> E): E 从右向左缩减 listOf(1, 2, 3).reduceRight { v, acc -> v - acc } // 2
scan(initial: R, operation: (acc: R, E) -> R): List<R> 累积折叠结果 listOf(1, 2, 3).scan(0) { a, b -> a + b } // [0, 1, 3, 6]
scanRight(initial: R, operation: (E, acc: R) -> R): List<R> 从右向左累积折叠结果 listOf(1, 2, 3).scanRight(0) { v, a -> v + a } // [6, 5, 3, 0]
十、其他常用方法
方法 说明 示例
toString(): String 转换为字符串表示 listOf(1, 2, 3).toString() // "[1, 2, 3]"
joinToString(separator: String = ", "): String 自定义字符串拼接 listOf(1, 2, 3).joinToString("; ") // "1; 2; 3"
equals(other: Any?): Boolean 判断内容是否相等 listOf(1, 2).equals(listOf(1, 2)) // true
hashCode(): Int 计算哈希值 listOf(1, 2).hashCode() // 哈希值(因环境而异)
asSequence(): Sequence<E> 转换为序列(延迟计算) listOf(1, 2, 3).asSequence().map { it * 2 }.toList() // [2,4,6]
onEach(action: (E) -> Unit): List<E> 遍历元素并返回自身 listOf(1, 2).onEach { println(it) } // [1, 2]