当前位置： 首页 > news >正文

2.Kotlin 集合 List 所有方法

news 2025/8/20 8:52:57

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?获取元素，越界返回 nullval 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]
http://www.lryc.cn/news/625708.html

相关文章：

  • Js逆向案例 Scrape Spa2(Webpack自吐)
  • Ansible 大项目管理实践笔记：并行任务、角色管理与负载均衡架构部署
  • 基于Python的宠物服务管理系统 Python+Django+Vue.js
  • 当机器猫遇上具身智能：一款能读懂宠物心思的AI守护者
  • XML 序列化与操作详解笔记
  • Gemini CLI 自定义主题配置
  • 块存储 对象存储 文件存储的区别与联系
  • es9.0.1语义检索简单示例
  • RNN（循环神经网络）和Transformer是处理自然语言处理（NLP）任务区别
  • 《用Proxy解构前端壁垒：跨框架状态共享库的从零到优之路》
  • 高校数字化转型实战：破解数据孤岛、构建智能指标体系与AI落地路径
  • C++代码解释：实现一个 mystring 类，用于表示字符串，实现构造函数，默认构造长度为 10 的空间，提供打印字符串，获取空间大小，修改内容的成员函数
  • InnoDB为什么使用B+树实现索引？
  • Word——正确调整文字与编号的距离
  • 4.Kotlin 集合 Map 所有方法
  • Linux系统安全补丁管理与自动化部署研究与实现（LW+源码+讲解+部署）
  • Ubuntu 20 各种网卡配置IP的方法
  • pnpm 和 npm 差异
  • MySQL 三大日志：redo log、undo log、binlog 详解
  • Git+Jenkins实战（一）
  • 软件测试核心概念拆解：需求、开发模型与测试模型全解析
  • JVM调优实战指南：从原理到落地的全面优化方案
  • 安装DDNS-go
  • FlexSim-线平衡优化仿真
  • Qt元对象
  • Qt消息队列
  • es7.x es的高亮与solr高亮查询的对比对比说明
  • 使用Tomcat Clustering和Redis Session Manager实现Session共享
  • Auto-CoT：大型语言模型的自动化思维链提示技术
  • 基于“R语言+遥感“水环境综合评价方法技术应用——水线提取、水深提取、水温提、水质提取、水环境遥感等