9.1.1.9.4 列表特有的操作

5 分钟阅读

原文链接: https://kotlinlang.org/docs/list-operations.html

9.1.1.9.4 列表特有的操作

List 是 Kotlin 中最常用的内置集合类型。对列表元素的索引访问为列表提供了一组强大的操作。

按索引获取元素

列表支持所有通用的元素获取操作：elementAt()、first()、last()，以及获取单个元素中列出的其他操作。列表特有的地方在于对元素的索引访问，因此读取元素最简单的方式就是按索引获取。这通过 get() 函数（索引作为参数传入）或简写形式 [index] 语法实现。

如果列表大小小于指定的索引，就会抛出异常。另外有两个函数可以帮助你避免这类异常：

getOrElse() 让你提供一个函数，用于在集合中不存在该索引时计算要返回的默认值。
getOrNull() 返回 null 作为默认值。

1
2
3
4
5
6
7
8
9

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    println(numbers.get(0))
    println(numbers[0])
    //numbers.get(5)                         // 异常！
    println(numbers.getOrNull(5)) // null
    println(numbers.getOrElse(5, {it})) // 5
}

获取列表的部分内容

除了获取集合部分内容的通用操作之外，列表还提供 subList() 函数，它以列表的形式返回指定元素范围的视图。因此，如果原始集合中的某个元素发生变化，之前创建的子列表中的对应元素也会变化，反之亦然。

1
2
3
4
5

fun main() {
    val numbers = (0..13).toList()
    println(numbers.subList(3, 6))
}

查找元素位置

线性搜索

在任何列表中，你都可以使用 indexOf() 和 lastIndexOf() 函数查找元素的位置。它们返回列表中等于给定参数的元素的第一个和最后一个位置。如果没有这样的元素，两个函数都返回 -1。

1
2
3
4
5
6

fun main() {
    val numbers = listOf(1, 2, 3, 4, 2, 5)
    println(numbers.indexOf(2))
    println(numbers.lastIndexOf(2))
}

还有一对函数接收谓词，并搜索与之匹配的元素：

indexOfFirst() 返回匹配该谓词的第一个元素的索引，如果没有这样的元素则返回 -1。
indexOfLast() 返回匹配该谓词的最后一个元素的索引，如果没有这样的元素则返回 -1。

1
2
3
4
5
6

fun main() {
    val numbers = mutableListOf(1, 2, 3, 4)
    println(numbers.indexOfFirst { it > 2})
    println(numbers.indexOfLast { it % 2 == 1})
}

有序列表中的二分查找

还有一种在列表中搜索元素的方式——二分查找。它比其他内置搜索函数快得多，但要求列表按某种顺序排序（升序），该顺序可以是自然顺序，也可以是函数参数中提供的其他顺序。否则，结果是未定义的。

要在有序列表中搜索元素，请调用 binarySearch() 函数并传入要查找的值作为参数。如果存在这样的元素，函数返回它的索引；否则返回 (-insertionPoint - 1)，其中 insertionPoint 是该元素应被插入以保持列表有序的位置索引。如果存在多个具有给定值的元素，搜索可能返回其中任意一个的索引。

你也可以指定要搜索的索引范围：在这种情况下，函数只在提供的两个索引之间搜索。

1
2
3
4
5
6
7
8
9

fun main() {
    val numbers = mutableListOf("one", "two", "three", "four")
    numbers.sort()
    println(numbers)
    println(numbers.binarySearch("two")) // 3
    println(numbers.binarySearch("z")) // -5
    println(numbers.binarySearch("two", 0, 2)) // -3
}

使用比较器的二分查找

当列表元素不是 Comparable 时，你应提供一个 Comparator 供二分查找使用。列表必须按该 Comparator 升序排列。我们来看一个例子：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

data class Product(val name: String, val price: Double)

fun main() {
    val productList = listOf(
        Product("WebStorm", 49.0),
        Product("AppCode", 99.0),
        Product("DotTrace", 129.0),
        Product("ReSharper", 149.0))

    println(productList.binarySearch(Product("AppCode", 99.0), compareBy<Product> { it.price }.thenBy { it.name }))
}

这里有一个由不可比较的 Product 实例组成的列表，以及一个定义顺序的 Comparator：如果 p1 的价格小于 p2 的价格，则产品 p1 排在产品 p2 之前。于是，在按此顺序升序排列的列表中，我们用 binarySearch() 查找指定 Product 的索引。

当列表使用的顺序与自然顺序不同时，自定义比较器也很有用，例如对 String 元素使用不区分大小写的顺序。

1
2
3
4
5

fun main() {
    val colors = listOf("Blue", "green", "ORANGE", "Red", "yellow")
    println(colors.binarySearch("RED", String.CASE_INSENSITIVE_ORDER)) // 3
}

使用比较函数的二分查找

使用比较函数的二分查找让你无需提供显式的搜索值就能查找元素。它接收一个把元素映射为 Int 值的比较函数，并搜索该函数返回零的那个元素。列表必须按所提供的函数升序排列；换句话说，比较的返回值必须从列表的一个元素到下一个元素递增。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import kotlin.math.sign
data class Product(val name: String, val price: Double)

fun priceComparison(product: Product, price: Double) = sign(product.price - price).toInt()

fun main() {
    val productList = listOf(
        Product("WebStorm", 49.0),
        Product("AppCode", 99.0),
        Product("DotTrace", 129.0),
        Product("ReSharper", 149.0))

    println(productList.binarySearch { priceComparison(it, 99.0) })
}

使用比较器的二分查找和使用比较函数的二分查找都可以在列表范围内执行。

列表写操作

除了集合写操作中描述的集合修改操作之外，可变列表还支持特定的写操作。这类操作使用索引来访问元素，从而扩展了列表的修改能力。

添加

要在列表的指定位置添加元素，请使用 add() 和 addAll()，并额外传入用于插入元素的位置作为参数。位于该位置之后的所有元素都会向右移动。

1
2
3
4
5
6
7

fun main() {
    val numbers = mutableListOf("one", "five", "six")
    numbers.add(1, "two")
    numbers.addAll(2, listOf("three", "four"))
    println(numbers)
}

更新

列表还提供了替换指定位置元素的函数——set() 及其运算符形式 []。set() 不会改变其他元素的索引。

1
2
3
4
5
6

fun main() {
    val numbers = mutableListOf("one", "five", "three")
    numbers[1] =  "two"
    println(numbers)
}

fill() 只是把集合中的所有元素替换为指定的值。

1
2
3
4
5
6

fun main() {
    val numbers = mutableListOf(1, 2, 3, 4)
    numbers.fill(3)
    println(numbers)
}

移除

要从列表中移除指定位置的元素，请使用 removeAt() 函数并传入位置作为参数。位于被移除元素之后的所有元素索引都会减一。

1
2
3
4
5
6

fun main() {
    val numbers = mutableListOf(1, 2, 3, 4, 3)
    numbers.removeAt(1)
    println(numbers)
}

排序

在集合排序中，我们介绍了按特定顺序获取集合元素的操作。对于可变列表，标准库提供了类似的扩展函数，可以就地执行相同的排序操作。当你把这类操作应用于某个列表实例时，它会改变该实例中元素的顺序。

就地排序函数的名称与作用于只读列表的函数类似，只是没有 ed/d 后缀：

所有排序函数的名称中，用 sort* 代替 sorted*：sort()、sortDescending()、sortBy() 等等。
用 shuffle() 代替 shuffled()。
用 reverse() 代替 reversed()。

对可变列表调用 asReversed() 会返回另一个可变列表，它是原始列表的反向视图。对该视图所做的修改会反映到原始列表中。下面的示例展示了可变列表的排序函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fun main() {
    val numbers = mutableListOf("one", "two", "three", "four")

    numbers.sort()
    println("Sort into ascending: $numbers")
    numbers.sortDescending()
    println("Sort into descending: $numbers")

    numbers.sortBy { it.length }
    println("Sort into ascending by length: $numbers")
    numbers.sortByDescending { it.last() }
    println("Sort into descending by the last letter: $numbers")

    numbers.sortWith(compareBy<String> { it.length }.thenBy { it })
    println("Sort by Comparator: $numbers")

    numbers.shuffle()
    println("Shuffle: $numbers")

    numbers.reverse()
    println("Reverse: $numbers")
}

最后修改 September 13, 2026: 更新C和Cpp以及新增Kotlin和SwiftUI (d20dcaaa6)