重学Kotlin（七）集合

哆啦A梦z

已于 2023-09-01 17:36:49 修改

阅读量1.1k

点赞数 1

分类专栏：重学Kotlin 文章标签： kotlin android

于 2022-07-25 12:17:15 首次发布

本文链接：https://blog.csdn.net/zx_android/article/details/125927917

版权

重学Kotlin 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

集合概述

List 是一个有序集合，可通过索引（反映元素位置的整数）访问元素。元素顺序很重要并且可以重复。
Set 是唯一元素的集合。元素无顺序不可重复。
Map（或者字典）是一组键值对。键是唯一的，值可以重复。

var 集合可以进行重新赋值和更改其中元素
val 集合不可以进行重新赋值，但可以更改其中元素

Mutable翻译中文为：可变;可变的;易变的;
需要写操作的那么就需要Mutable开头
所有就有了

listOf()
mutableListOf()

setOf()
mutableSetOf()

mapOf()
mutableMapOf()

创建空集合需指定类型

   listOf(1,2,3)
   listOf<Int>()

val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3)

to 符号创建了一个短时存活的 Pair 对象，因此建议仅在性能不重要时才使用它。为避免过多的内存使用，可以创建可写 Map 并使用写入操作填充它。 apply() 函数可以帮助保持初始化流畅。

val numbersMap = mutableMapOf<String, String>().apply { this["one"] = "1"; this["two"] = "2" }

创建空集合时，应指定集合将包含的元素类型。

val empty1 = emptyList<String>()
val empty2 = emptySet<String>()
val empty3 = emptyMap<String,String>()

集合复制
如果在源集合中添加或删除元素，则不会影响副本。
副本也可以独立于源集合进行更改。

listOf<Int>().toList()
listOf<Int>().toMutableList()
listOf<Int>().toSet()
listOf<Int>().toMutableSet()

迭代器

Iterable 接口的继承者（包括 Set 与 List）可以通过调用 iterator() 函数获得迭代器。
一旦获得迭代器它就指向集合的第一个元素；调用 next() 函数将返回此元素，并将迭代器指向下一个元素（如果下一个元素存在）。
三种迭代数据的方式
方式一

val numbers = listOf("one", "two", "three", "four")
    val numbersIterator = numbers.iterator()
    while (numbersIterator.hasNext()) {
        println(numbersIterator.next())
    }

方式二

val numbers = listOf("one", "two", "three", "four")
  for (item in numbers) {
        println(item)
    }
  for ((index,value) in numbers.withIndex()) {
            index
            value
        }
  for (item in numbers.withIndex()) {
            item.index
            item.value
        }
  for (index in numbers.indices) {
          numbers[index]
        }

方式三

 val numbers = listOf("one", "two", "three", "four")
    numbers.forEach {
        println(it)
    }

对于列表，有一个特殊的迭代器实现： ListIterator。它支持列表双向迭代：正向与反向。

val numbers = listOf("one", "two", "three", "four")
    val listIterator = numbers.listIterator()
    while (listIterator.hasNext()) listIterator.next()
    println("Iterating backwards:")
    while (listIterator.hasPrevious()) {
        print("Index: ${listIterator.previousIndex()}")
        println(", value: ${listIterator.previous()}")
    }

可变迭代器

迭代可变集合并增删改
新增和修改：MutableListIterator
删除：MutableIterator

 val numbers = mutableListOf("one", "four", "four")
    val mutableListIterator = numbers.listIterator()

    mutableListIterator.next()
    mutableListIterator.add("two")
    mutableListIterator.next()
    mutableListIterator.set("three")
    println(numbers)

 val numbers = mutableListOf("one", "two", "three", "four") 
    val mutableIterator = numbers.iterator()

    mutableIterator.next()
    mutableIterator.remove()    
    println("After removal: $numbers")

区间 in，downTo，step，until

if (i in 1..4) {  // 等同于 1 <= i && i <= 4
    print(i)
}
结果：1234
//反向迭代
for (i in 4 downTo 1) {
print(i)
}
结果：4321

增加步长

for (i in 1..8 step 2) print(i)//取索引：1，1+2，3+2，5+2
println()
for (i in 8 downTo 1 step 2) print(i)//取索引：8，8-2，6-2，4-2
结果：
1357
8642

不包含结尾数据

for (i in 1 until 10) {       // i in [1, 10), 10被排除
    print(i)
}

序列

序列：特殊场景大数据量替代集合的方案
Kotlin 中的序列（sequence）

集合中的拓展函数

集合转换

map，mapIndexed

val numbers = setOf(1, 2, 3)
println(numbers.map { it * 3 })
println(numbers.mapIndexed { idx, value -> value * idx })
结果：
[3, 6, 9]
[0, 2, 6]

过滤掉 null 值可以使用

mapNotNull() ， mapIndexedNotNull()

val numbers = setOf(1, 2, 3)
println(numbers.mapNotNull { if ( it == 2) null else it * 3 })
println(numbers.mapIndexedNotNull { idx, value -> if (idx == 0) null else value * idx })
结果：
[3, 9]
[2, 6]

如果集合是键值对，使用

mapKeys ，mapValues

mapKeys ：括号里的条件应用于键
mapValues ：括号里的条件应用于值

val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
println(numbersMap.mapKeys { it.key.toUpperCase() })
println(numbersMap.mapValues { it.value + it.key.length })
结果：返回为键值对
{KEY1=1, KEY2=2, KEY3=3, KEY11=11}
{key1=5, key2=6, key3=7, key11=16}

两个集合和键值对相互转换

zip ，unzip

val colors = listOf("red", "brown", "grey")
        val animals = listOf("fox", "bear", "wolf")
        val news = colors zip animals
        for (new in news){
            println("${new.first},${new.second}")
        }

val twoAnimals = listOf("fox", "bear")
println(colors.zip(twoAnimals))

结果：
red,fox
brown,bear
grey,wolf
[(red, fox), (brown, bear)]

另一种写法，color和animal 为两个集合的元素

val colors = listOf("red", "brown", "grey")
val animals = listOf("fox", "bear", "wolf")

println(colors.zip(animals) { color, animal -> "The ${animal.capitalize()} is $color"})
结果：
[The Fox is red, The Bear is brown, The Wolf is grey]

val numberPairs = listOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
println(numberPairs.unzip())
结果：
([one, two, three, four], [1, 2, 3, 4])

通过集合构建键值对

associateWith，associateBy，associateBy()，associate()

associateWith：集合中的值作为新集合的key
associateBy：集合中的值作为新集合的value
associateBy()：集合中的值作为新集合的value，函数方式构建
associate()：函数方式构建

val numbers = listOf("one", "two", "three", "four")
println(numbers.associateWith { it.length })
结果：
{one=3, two=3, three=5, four=4}

val numbers = listOf("one", "two", "three", "four")
println(numbers.associateBy { it.length })
结果：key不可重复所以是3个元素
{3=two, 5=three, 4=four}

带参数的写法

println(numbers.associateBy(keySelector = { it.length }, valueTransform = { it }))
结果：返回为键值对
{3=two, 5=three, 4=four}

val numbers = listOf("one", "two", "three", "four")
println(numbers.associate { n -> n to n.length })  
结果：返回为键值对
{one=3, two=3, three=5, four=4}

对嵌套的集合进行打平使用

flatten,flatMap

flatMap = 先调用map后调用flatten

val numberSets = listOf(setOf(1, 2, 3), setOf(4, 5, 6), setOf(1, 2))
println(numberSets.flatten())
结果：
[1, 2, 3, 4, 5, 6, 1, 2]

集合转换为字符串

joinToString，joinTo

val numbers = listOf("one", "two", "three", "four")

println(numbers)         
println(numbers.joinToString())

val listString = StringBuffer("The list of numbers: ")
numbers.joinTo(listString)
println(listString)
结果：
[one, two, three, four]
one, two, three, four
The list of numbers: one, two, three, four

自定义字符串可以指定参数

val numbers = listOf("one", "two", "three", "four")    
println(numbers.joinToString(separator = " | ", prefix = "start: ", postfix = ": end"))
结果：返回为字符串
start: one | two | three | four: end

较大的集合，超出 limit的其他元素被 truncated 参数的单个值替换。

val numbers = (1..100).toList()
println(numbers.joinToString(limit = 10, truncated = "<...>"))
结果：
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, <...>

修改元素的表现格式

val numbers = listOf("one", "two", "three", "four")
println(numbers.joinToString { "Element: ${it.toUpperCase()}"})
结果：返回为字符串
Element: ONE, Element: TWO, Element: THREE, Element: FOUR

集合过滤

filter，filterNot，filterNotNull，filterIndexed，filterIsInstance

filter，filterNot：只检查元素的值
filterNotNull：返回非空元素
filterIndexed：检查元素的索引和元素的值
filterIsInstance：返回指定类型的元素

val numbers = listOf("one", "two", "three", "four")  
val longerThan3 = numbers.filter { it.length > 3 }
println(longerThan3)

val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
val filteredMap = numbersMap.filter { (key, value) -> key.endsWith("1") && value > 10}
println(filteredMap)
结果：
[three, four]
{key11=11}

val numbers = listOf("one", "two", "three", "four")

val filteredIdx = numbers.filterIndexed { index, s -> (index != 0) && (s.length < 5)  }
val filteredNot = numbers.filterNot { it.length <= 3 }


println(filteredIdx)
println(filteredNot)

val numbers2 = listOf(null, "one", "two", null)
numbers2.filterNotNull().forEach {
    println("长度"+it.length)   // 对可空的 String 来说长度不可用
}
结果：
[two, four]
[three, four]
长度3
长度3

val numbers = listOf(null, 1, "two", 3.0, "four")
println("All String elements in upper case:")
numbers.filterIsInstance<String>().forEach {
    println(it.toUpperCase())
}
结果：提取了类型为String的数据
All String elements in upper case:
TWO
FOUR

过滤 map 的特定函数：按键或按值。这两种方式，都有对应的函数： filterKeys() 和 filterValues() 。两者都将返回一个新 Map

filterKeys，filterValues

val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
val filteredKeysMap = numbersMap.filterKeys { it.endsWith("1") }
val filteredValuesMap = numbersMap.filterValues { it < 10 }

println(filteredKeysMap)
println(filteredValuesMap)
结果：
{key1=1, key11=11}
{key1=1, key2=2, key3=3}

1个集合分为2个集合，符合条件的和不符合条件的

划分partition

val numbers = listOf("one", "two", "three", "four")
val (match, rest) = numbers.partition { it.length > 3 }

println(match)
println(rest)
结果：
[three, four]
[one, two]

检验any，one，all

any：集合元素只要有一个包含返回true
none：集合元素都不包含返回true
all：集合元素都包含返回true
空集合永远返回true

val numbers = listOf("one", "two", "three", "four")

println(numbers.any { it.endsWith("e") })
println(numbers.none { it.endsWith("a") })
println(numbers.all { it.endsWith("e") })
//空集合调用这3个函数都返回true
println(emptyList<Int>().all { it > 5 })   // vacuous truth
结果：
true
true
false
true

any() 和 none() 不带参数只能检查集合是否为空

加减操作符

在 Kotlin 中，为集合定义了 plus (+) 和 minus (-) 操作符。它们把一个集合作为第一个操作数；第二个操作数可以是一个元素或者是另一个集合。返回值是一个新的只读集合：

val numbers = listOf("one", "two", "three", "four")

val plusList = numbers + "five"
val minusList = numbers - listOf("three", "four")
println(plusList)
println(minusList)
结果：返回为list
[one, two, three, four, five]
[one, two]

分组groupBy ，groupingBy

val numbers = listOf("one", "two", "three", "four", "five")

println(numbers.groupBy { it.first().toUpperCase() })
println(numbers.groupBy(keySelector = { it.first() }, valueTransform = { it.toUpperCase() }))
结果：返回为键值对
{O=[one], T=[two, three], F=[four, five]}
{o=[ONE], t=[TWO, THREE], f=[FOUR, FIVE]}

取集合的一部分

slice，take，takeLast，drop，dropLast

slice：返回给定索引的集合元素列表
take：从头开始获取指定数量的元素
takeLast：从尾开始获取指定数量的元素
drop：从头去除给定数量的元素
dropLast：从尾去除给定数量的元素


val numbers = listOf("one", "two", "three", "four", "five", "six")    
println(numbers.slice(1..3))
println(numbers.slice(0..4 step 2))//0,0+2,2+2
println(numbers.slice(setOf(3, 5, 0)))  
结果：返回list
[two, three, four]
[one, three, five]
[four, six, one]

val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.take(3))
println(numbers.takeLast(3))
println(numbers.drop(1))
println(numbers.dropLast(5))
结果：返回list
[one, two, three]
[four, five, six]
[two, three, four, five, six]
[one]

takeWhile，takeLastWhile，dropWhile，dropLastWhile

takeWhile：从头循环获取指定条件元素，直到碰到首个不符合条件元素终止获取
takeLastWhile：从尾循环获取指定条件元素，直到碰到首个不符合条件元素终止获取
dropWhile：从头循环去除指定条件元素，直到碰到首个不符合条件元素终止去除
dropLastWhile：从尾循环去除指定条件元素，直到碰到首个不符合条件元素终止去除

val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.takeWhile { !it.startsWith('f') })
println(numbers.takeLastWhile { it != "three" })
println(numbers.dropWhile { it.length == 3 })
println(numbers.dropLastWhile { it.contains('i') })
结果：返回符合条件的集合
[one, two, three]
[four, five, six]
[three, four, five, six]
[one, two, three, four]

Chunked

一个集合根据指定length分成多个子集合

val numbers = (0..13).toList()
println(numbers.chunked(3))
结果：返回嵌套集合
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13]]

对子集合进行累加

val numbers = (0..13).toList() 
println(numbers.chunked(3) { it.sum() })
结果：返回集合
[3, 12, 21, 30, 25]

Windowed，zipWithNext

一个集合根据指定length分成多个子集合，但每个索引都取

val numbers = listOf("one", "two", "three", "four", "five")    
println(numbers.windowed(3))
结果：
[[one, two, three], [two, three, four], [three, four, five]]

可选参数更灵活

val numbers = (1..10).toList()
//partialWindows = true 代表最后[9, 10]补足
println(numbers.windowed(3, step = 2, partialWindows = true))
println(numbers.windowed(3) { it.sum() })
结果:
[[1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9], [9, 10]]
[6, 9, 12, 15, 18, 21, 24, 27]

    val numbers = listOf("one", "two", "three", "four", "five")    
    println(numbers.zipWithNext())
    println(numbers.zipWithNext() { s1, s2 -> s1.length > s2.length})
    结果：返回键值对，返回集合
    [(one, two), (two, three), (three, four), (four, five)]
   [false, false, true, false]

取单个元素

elementAt，elementAtOrNull，elementAtOrElse，first，last，firstOrNull，lastOrNull，find，findLast，random

elementAt：下标越界会抛异常，对于不提供索引访问或非静态已知提供索引访问的集合很有用。在使用 List 的情况下，使用索引访问操作符（get() 或 []）更为习惯。
elementAtOrNull：下标越界返回null，不会抛异常
elementAtOrElse：下标越界返回指定错误
first：获取第一个元素，下标越界会抛异常
last：获取最后一个元素，下标越界会抛异常
firstOrNull：下标越界返回null，不会抛异常
lastOrNull：下标越界返回null，不会抛异常
find：代替 firstOrNull()
findLast：代替 lastOrNull()
random：随机

val numbers = linkedSetOf("one", "two", "three", "four", "five")
println(numbers.elementAt(3))    

val numbersSortedSet = sortedSetOf("one", "two", "three", "four")
println(numbersSortedSet.elementAt(0)) // 元素以升序存储
结果：
four
four

val numbers = listOf("one", "two", "three", "four", "five")
println(numbers.elementAtOrNull(5))
println(numbers.elementAtOrElse(5) { index -> "The value for index $index is undefined"})
结果：
null
The value for index 5 is undefined

val numbers = listOf("one", "two", "three", "four", "five")
println(numbers.first())    
println(numbers.last())  
结果：
one
five

val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.first { it.length > 3 })
println(numbers.last { it.startsWith("f") })
结果：
three
five

val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.firstOrNull { it.length > 6 })
结果：
null

val numbers = listOf(1, 2, 3, 4)
println(numbers.find { it % 2 == 0 })
println(numbers.findLast { it % 2 == 0 })
结果：
2
4

val numbers = listOf(1, 2, 3, 4)
println(numbers.random())
结果：
随机

contains，in ，isEmpty，isNotEmpty

你可以使用 in 关键字以操作符的形式调用 contains()

val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.contains("four"))
println("zero" in numbers)

println(numbers.containsAll(listOf("four", "two")))
println(numbers.containsAll(listOf("one", "zero")))
结果：
true
false
true
false

isEmpty() 和 isNotEmpty() 来检查集合中是否包含任何元素。

val numbers = listOf("one", "two", "three", "four", "five", "six")
println(numbers.isEmpty())
println(numbers.isNotEmpty())

val empty = emptyList<String>()
println(empty.isEmpty())
println(empty.isNotEmpty())
结果：
false
true
true
false

排序

sortedWith，compareBy

sortedWith：接收一个自定义的Comparator
compareBy：根据条件生成自定义Comparator

如需为类型定义自定义顺序，可以为其创建一个 Comparator。 Comparator 包含 compare() 函数：它接受一个类的两个实例并返回它们之间比较的整数结果

class Version(val major: Int, val minor: Int): Comparable<Version> {
    override fun compareTo(other: Version): Int {
        if (this.major != other.major) {
            return this.major - other.major
        } else if (this.minor != other.minor) {
            return this.minor - other.minor
        } else return 0
    }
}

fun main() {    
    println(Version(1, 2) > Version(1, 3))
    println(Version(2, 0) > Version(1, 5))
}
结果：
false
true

根据长度排序

val lengthComparator = Comparator { str1: String, str2: String -> str1.length - str2.length }
println(listOf("aaa", "bb", "c").sortedWith(lengthComparator))
结果：
[c, bb, aaa]

使用compareBy 根据条件排序

println(listOf("aaa", "bb", "c").sortedWith(compareBy { it.length }))
结果：
[c, bb, aaa]

自然顺序sorted，sortedDescending

val numbers = listOf("ane", "cwo", "bhree", "dour")

println("Sorted ascending: ${numbers.sorted()}")
println("Sorted descending: ${numbers.sortedDescending()}")
结果：默认按照首字母顺序进行了排序
Sorted ascending: [ane, bhree, cwo, dour]
Sorted descending: [dour, cwo, bhree, ane]

自定义顺序sortedBy，sortedByDescending

val numbers = listOf("one", "two", "three", "four")

val sortedNumbers = numbers.sortedBy { it.length }
println("$sortedNumbers")
val sortedByLast = numbers.sortedByDescending { it.length }
println("$sortedByLast")
结果：
[one, two, four, three]
[three, four, one, two]

使用sortedWith 接收自定义Comparator

println(listOf("aaa", "bb", "c").sortedWith(compareBy { it.length }))
结果：
[c, bb, aaa]

倒序reversed，asReversed

reversed：原始列表发送变化，倒序集合不会变化
asReversed：原始列表发生变化，倒序集合也会变化

如果原始列表不会发生变化，asReversed会比 reversed 更轻量，更合适。

val numbers = mutableListOf("one", "two", "three", "four")
val reversedNumbers = numbers.reversed()
println(reversedNumbers)
numbers.add("five")
println(reversedNumbers)
结果：
[four, three, two, one]
[four, three, two, one]

val numbers = mutableListOf("one", "two", "three", "four")
val reversedNumbers = numbers.asReversed()
println(reversedNumbers)
numbers.add("five")
println(reversedNumbers)
结果：
[four, three, two, one]
[five, four, three, two, one]

随机排序

val numbers = listOf("one", "two", "three", "four")
println(numbers.shuffled())
结果：
随机顺序

集合聚合操作

min，max，average，sum，count

min() 与 max() 分别返回最小和最大的元素；
average() 返回数字集合中元素的平均值；
sum() 返回数字集合中元素的总和；
count() 返回集合中元素的数量；

val numbers = listOf(6, 42, 10, 4)

println("Count: ${numbers.count()}")
println("Max: ${numbers.max()}")
println("Min: ${numbers.min()}")
println("Average: ${numbers.average()}")
println("Sum: ${numbers.sum()}")
结果：
Count: 4
Max: 42
Min: 4
Average: 15.5
Sum: 62

还有一些通过某些选择器函数或自定义 Comparator 来检索最小和最大元素的函数。

maxBy，minBy，maxWith，minWith

maxBy()/minBy() 接受一个选择器函数并返回使选择器返回最大或最小值的元素。
maxWith()/minWith() 接受一个 Comparator 对象并且根据此 Comparator 对象返回最大或最小元素

val numbers = listOf(5, 12, 10, 4)
val min3Remainder = numbers.minBy { it % 3 }
println(min3Remainder)

val strings = listOf("one", "two", "three", "four")
val longestString = strings.maxWith(compareBy { it.length })
println(longestString)
结果：
12
three

此外，有一些高级的求和函数，它们接受一个函数并返回对所有元素调用此函数的返回值的总和：

sumBy，sumByDouble

sumBy() 使用对集合元素调用返回 Int 值的函数。
sumByDouble() 与返回 Double 的函数一起使用

val numbers = listOf(5, 12, 10, 4)
println(numbers.sumBy { it * 2 })
println(numbers.sumByDouble { it.toDouble() / 2 })
结果：
62
15.5

Fold 与 reduce的累加

Fold ，reduce

它们依次将所提供的操作应用于集合元素并返回累积的结果。
操作有两个参数：先前的累积值和集合元素。

fold() 接受一个初始值并将其用作第一步的累积值
reduce() 则将第一个和第二个元素作为第一步的操作参数

val numbers = listOf(5, 2, 10, 4)

val sum = numbers.reduce { sum, element -> sum + element }
println(sum)
val sumDoubled = numbers.fold(1) { sum, element -> sum + element * 2 }
println(sumDoubled)
结果：
21
43

上面的实例展示了区别：fold() 用于计算加倍的元素之和。如果将相同的函数传给 reduce()，那么它会返回另一个结果，因为在第一步中它将列表的第一个和第二个元素作为参数，所以第一个元素不会被加倍。

reduceRight，foldRight

如需将函数以相反的顺序应用于元素，可以使用函数 reduceRight() 和 foldRight() 它们的工作方式类似于 fold() 和 reduce()，但从最后一个元素开始，然后再继续到前一个元素。记住，在使用 foldRight 或 reduceRight 时，操作参数会更改其顺序：第一个参数变为元素，然后第二个参数变为累积值。

val numbers = listOf(5, 2, 10, 4)
val sumDoubledRight = numbers.foldRight(0) { element, sum -> sum + element * 2 }
println(sumDoubledRight)
结果：
42

reduceIndexed，foldIndexed，reduceRightIndexed，foldRightIndexed

你还可以使用将元素索引作为参数的操作。为此，使用函数 reduceIndexed() 和 foldIndexed() 传递元素索引作为操作的第一个参数。

最后，还有将这些操作从右到左应用于集合元素的函数——reduceRightIndexed() 与 foldRightIndexed()

val numbers = listOf(5, 2, 10, 4)
val sumEven = numbers.foldIndexed(0) { idx, sum, element -> if (idx % 2 == 0) sum + element else sum }
println(sumEven)

val sumEvenRight = numbers.foldRightIndexed(0) { idx, element, sum -> if (idx % 2 == 0) sum + element else sum }
println(sumEvenRight)
结果：
15
15

所有reduce操作都会在空集合上引发异常。要接收null，请使用其*OrNull
reduceOrNull()
reduceRightOrNull()
reduceIndexedOrNull()
reduceRightIndexedOrNull()

集合写操作

添加元素

addAll() 将参数对象的每个元素添加到列表或集合中。参数可以是 Iterable、Sequence 或 Array。接收者的类型和参数可能不同，例如，你可以将所有内容从 Set 添加到 List。

val numbers = mutableListOf(1, 2, 5, 6)
numbers.addAll(arrayOf(7, 8))
println(numbers)
numbers.addAll(2, setOf(3, 4))
println(numbers)

+=

+= 将元素或者集合追加到集合的末尾。

val numbers = mutableListOf("one", "two")
numbers += "three"
println(numbers)
numbers += listOf("four", "five")    
println(numbers)
结果：
[one, two, three]
[one, two, three, four, five]

删除元素

remove，removeAll，retainAll，clear，removeAt

删除单个元素

val numbers = mutableListOf(1, 2, 3, 4, 3)
numbers.remove(3)                    // 删除了第一个 `3`
println(numbers)
numbers.remove(5)                    // 什么都没删除
println(numbers)
结果：
[1, 2, 4, 3]
[1, 2, 4, 3]

删除多个元素
removeAll() 移除参数集合中存在的所有元素。或者，你可以用谓词作为参数来调用它；在这种情况下，函数移除谓词产生 true 的所有元素。
retainAll() 与 removeAll() 相反：它移除除参数集合中的元素之外的所有元素。当与谓词一起使用时，它只留下与之匹配的元素。
clear() 从列表中移除所有元素并将其置空。

val numbers = mutableListOf(1, 2, 3, 4)
println(numbers)
numbers.retainAll { it >= 3 }
println(numbers)
numbers.clear()
println(numbers)

val numbersSet = mutableSetOf("one", "two", "three", "four")
numbersSet.removeAll(setOf("one", "two"))
println(numbersSet)
结果：
[1, 2, 3, 4]
[3, 4]
[]
[three, four]

要从列表中删除指定位置的元素，请使用 removeAt() 函数

val numbers = mutableListOf(1, 2, 3, 4, 3)    
numbers.removeAt(1)
println(numbers)
结果：
[1, 3, 4, 3]

removeFirst() ， removeLast() ，removeFirstOrNull() ， removeLastOrNull()

val numbers = mutableListOf(1, 2, 3, 4, 3)    
numbers.removeFirst()
numbers.removeLast()
println(numbers)

val empty = mutableListOf<Int>()
// empty.removeFirst() // NoSuchElementException: List is empty.
empty.removeFirstOrNull() //null
结果：
[2, 3, 4]

-=

右边是单个元素时，-= 会移除它的第一个匹配项

val numbers = mutableListOf("one", "two", "three", "three", "four")
numbers -= "three"
println(numbers)
//第二个操作数可以包含集合中不存在的元素。这些元素不会影响操作的执行。
numbers -= listOf("four", "five")    
//numbers -= listOf("four")    // 与上述相同
println(numbers)    
结果：
[one, two, three, four]
[one, two, three]

更新元素

fill() 简单地将所有集合元素的值替换为指定值

val numbers = mutableListOf(1, 2, 3, 4)
numbers[1] =  9
println(numbers)
numbers.fill(3)
println(numbers)
结果：
[1, 9, 3, 4]
[3, 3, 3, 3]

List，Set，Map常用操作

List

get，[0]，getOrNull，getOrElse，subList

取元素
getOrElse() 如果集合中不存在索引，则返回默认值。
getOrNull() 返回 null 作为默认值。

val numbers = listOf(1, 2, 3, 4)
println(numbers.get(0))
println(numbers[0])
//numbers.get(5)                         // exception!
println(numbers.getOrNull(5))             // null
println(numbers.getOrElse(5, {it}))  
结果：
1
1
null
5

取集合的一部分subList

val numbers = (0..13).toList()
println(numbers.subList(3, 6))
结果：
[3, 4, 5]

查找元素位置indexOf，lastIndexOf，indexOfFirst()，indexOfLast()，

indexOf() 或 lastIndexOf() 函数找到元素的位置。它们返回与列表中给定参数相等的元素的第一个或最后一个位置

val numbers = listOf(1, 2, 3, 4, 2, 5)
println(numbers.indexOf(2))
println(numbers.lastIndexOf(2))
结果：
1
4

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

binarySearch

Set

union（a union b），intersect（a intersect b），subtract（a subtract b）

并集： union（a union b）
交集：intersect（a intersect b）
差集：subtract（a subtract b）

val numbers = setOf("one", "two", "three")

println(numbers union setOf("four", "five"))
println(setOf("four", "five") union numbers)

println(numbers intersect setOf("two", "one"))
println(numbers subtract setOf("three", "four"))
println(numbers subtract setOf("four", "three")) // 相同的输出
结果：
[one, two, three, four, five]
[four, five, one, two, three]
[one, two]
[one, two]
[one, two]

Map

get(key)，[key]:如果找不到给定的键，则返回 null
getValue() ，如果在 Map 中找不到键，则抛出异常。

getOrElse() 与 list 的工作方式相同：对于不存在的键，其值由给定的 lambda 表达式返回。
getOrDefault() 如果找不到键，则返回指定的默认值。

val numbersMap = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap.get("one"))
println(numbersMap["one"])
println(numbersMap.getOrDefault("four", 10))
println(numbersMap["five"])               // null
//numbersMap.getValue("six")      // exception!
结果：
1
1
10
null

获取所有key和value

val numbersMap = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap.keys)
println(numbersMap.values)
结果：
[one, two, three]
[1, 2, 3]

plus（+）与 minus（-）运算符

val numbersMap = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap + Pair("four", 4))
println(numbersMap + Pair("one", 10))
println(numbersMap + mapOf("five" to 5, "one" to 11))
结果：
{one=1, two=2, three=3, four=4}
{one=10, two=2, three=3}
{one=11, two=2, three=3, five=5}

val numbersMap = mapOf("one" to 1, "two" to 2, "three" to 3)
println(numbersMap - "one")
println(numbersMap - listOf("two", "four"))
结果：
{two=2, three=3}
{one=1, three=3}

put，putAll 添加或修改，+=，set，[key]

val numbersMap = mutableMapOf("one" to 1, "two" to 2, "three" to 3)
numbersMap.put("three", 88)
numbersMap.putAll(setOf("three" to 99,"four" to 4, "five" to 5))
println(numbersMap)
结果:
{one=1, two=2, three=99, four=4, five=5}

val numbersMap = mutableMapOf("one" to 1, "two" to 2)
numbersMap["three"] = 3     // 调用 numbersMap.set("three", 3)
numbersMap += mapOf("four" to 4, "five" to 5)
println(numbersMap)
结果：
{one=1, two=2, three=3, four=4, five=5}

删除条目

要从可变 Map 中删除条目，请使用 remove() 函数。调用 remove() 时，可以传递键或整个键值对。如果同时指定键和值，则仅当键值都匹配时，才会删除此的元素

val numbersMap = mutableMapOf("one" to 1, "two" to 2, "three" to 3)
numbersMap.remove("one")
println(numbersMap)
numbersMap.remove("three", 4)            //不会删除任何条目
println(numbersMap)
结果：
{two=2, three=3}
{two=2, three=3}

还可以通过键或值从可变 Map 中删除条目。在 Map 的 .keys 或 .values 中调用 remove() 并提供键或值来删除条目。在 .values 中调用时， remove() 仅删除给定值匹配到的的第一个条目。

val numbersMap = mutableMapOf("one" to 1, "two" to 2, "three" to 3, "threeAgain" to 3)
numbersMap.keys.remove("one")
println(numbersMap)
numbersMap.values.remove(3)
println(numbersMap)
结果:
{two=2, three=3, threeAgain=3}
{two=2, threeAgain=3}

val numbersMap = mutableMapOf("one" to 1, "two" to 2, "three" to 3)
numbersMap -= "two"
println(numbersMap)
numbersMap -= "five"             //不会删除任何条目
println(numbersMap)
结果：
{one=1, three=3}
{one=1, three=3}