Kotlin学习笔记(8)--集合

集合操作

在Kotlin中，集合是用于存储一组相关数据的容器。Kotlin 提供了丰富的集合类型和操作，允许开发者高效地管理和操作数据。Kotlin 的集合分为两大类：

1. 只读集合（Read-Only Collections）：不支持修改操作，如添加、删除或更新元素。主要用于数据的读取和遍历。
2. 可变集合（Mutable Collections）：支持修改操作，可以动态地添加、删除或更新元素。

以下是Kotlin中常用的集合类型：

• List：有序的集合，允许重复元素。
• Set：无序的集合，不允许重复元素。
• Map：键值对的集合，键唯一，值可以重复。

List（列表）

特点

• 有序的集合，元素按照插入顺序排列。
• 允许重复元素。

常用接口与实现

• List：只读列表接口。
• MutableList：可变列表接口，支持添加、删除和修改元素。
• 实现类：ArrayList, LinkedList 等。

示例

// 创建只读列表
val readOnlyList: List<String> = listOf("Apple", "Banana", "Cherry")

// 创建可变列表
val mutableList: MutableList<String> = mutableListOf("Apple", "Banana", "Cherry")
mutableList.add("Date")
mutableList.remove("Banana")
println(mutableList) // 输出: [Apple, Cherry, Date]

Set（集合）

特点

• 无序的集合，元素没有固定顺序。
• 不允许重复元素。

常用接口与实现

• Set：只读集合接口。
• MutableSet：可变集合接口，支持添加和删除元素。
• 实现类：HashSet, LinkedHashSet, TreeSet 等。

示例

// 创建只读集合
val readOnlySet: Set<Int> = setOf(1, 2, 3, 4, 5)

// 创建可变集合
val mutableSet: MutableSet<Int> = mutableSetOf(1, 2, 3)
mutableSet.add(4)
mutableSet.add(2) // 重复元素不会被添加
println(mutableSet) // 输出: [1, 2, 3, 4]

Map（映射）

特点

• 存储键值对（key-value pairs）。
• 键（Key）唯一，值（Value）可以重复。

常用接口与实现

• Map：只读映射接口。
• MutableMap：可变映射接口，支持添加、删除和修改键值对。
• 实现类：HashMap, LinkedHashMap, TreeMap 等。

示例

// 创建只读映射
val readOnlyMap: Map<String, Int> = mapOf("Apple" to 1, "Banana" to 2, "Cherry" to 3)

// 创建可变映射
val mutableMap: MutableMap<String, Int> = mutableMapOf("Apple" to 1, "Banana" to 2)
mutableMap["Cherry"] = 3
mutableMap.remove("Banana")
println(mutableMap) // 输出: {Apple=1, Cherry=3}

集合高阶操作

Kotlin 提供了许多强大的集合操作函数，允许以声明式的方式处理数据。

常用高阶函数

map：将集合中的每个元素转换为另一种形式。

val numbers = listOf(1, 2, 3, 4)
val squares = numbers.map { it * it }
println(squares) // 输出: [1, 4, 9, 16]

filter：筛选出符合条件的元素。

val numbers = listOf(1, 2, 3, 4)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers) // 输出: [2, 4]

reduce：将集合中的元素累积为单一值。

val numbers = listOf(1, 2, 3, 4)
val sum = numbers.reduce { acc, number -> acc + number }
println(sum) // 输出: 10

fold：与 reduce 类似，但允许设置初始值。

val numbers = listOf(1, 2, 3, 4)
val product = numbers.fold(1) { acc, number -> acc * number }
println(product) // 输出: 24

sorted：对集合进行排序。

val unsorted = listOf(3, 1, 4, 2)
val sorted = unsorted.sorted()
println(sorted) // 输出: [1, 2, 3, 4]

集合转换

转换为其他集合类型：

val list = listOf(1, 2, 3)
val set = list.toSet()
val map = list.associateWith { it * 2 }
println(set) // 输出: [1, 2, 3]
println(map) // 输出: {1=2, 2=4, 3=6}

扁平化集合：

val nestedList = listOf(listOf(1, 2), listOf(3, 4))
val flatList = nestedList.flatten()
println(flatList) // 输出: [1, 2, 3, 4]

惰性集合操作

在处理大数据集或需要链式操作时，Kotlin 提供了序列（Sequence）来实现惰性计算，提升性能。

• 序列与普通集合不同，对序列的操作不会立即执行，而是在遍历序列时逐步执行。

val numbers = generateSequence(1) { it + 1 }.take(1000000).toList() // 建立一个从 1 累加到 1000000 的序列。

val result = numbers
    .asSequence()
    .filter { it % 2 == 0 } //对序列进行过滤操作，只保留那些能被 2 整除的元素（即偶数）。
    .map { it * it }  // 对过滤后的序列中的每个元素进行映射操作，将每个偶数变为它的平方。
    .take(10) //从映射后的序列中只取前 10 个元素。
    .toList() 

println(result) // 输出前10个偶数的平方