2-1-4 快速掌握Kotlin-集合框架Kotlin 集合框架 Kotlin 提供了强大且类型安全的集合框架，它在 J

Kotlin 集合框架

Kotlin 提供了强大且类型安全的集合框架，它在 Java 集合基础上进行了扩展和优化。

集合类型概述

1. 集合分类

// 按可变性分类
val immutableList: List<String> = listOf("a", "b", "c")    // 不可变
val mutableList: MutableList<String> = mutableListOf("a", "b", "c")  // 可变

// 按结构分类
// List - 有序，可重复
// Set - 无序，不可重复
// Map - 键值对

2. 创建集合

列表 (List)

// 只读列表
val list1 = listOf("A", "B", "C")
val emptyList = emptyList<String>()

// 可变列表
val mutableList1 = mutableListOf(1, 2, 3)
val arrayList = arrayListOf("x", "y", "z")

// 构建器模式（Kotlin 1.3+）
val builtList = buildList {
    add("first")
    addAll(listOf("second", "third"))
}

// 其他创建方式
val sizedList = List(5) { index -> "Item $index" }  // ["Item 0", "Item 1"...]

集合 (Set)

// 只读集合
val set1 = setOf(1, 2, 3, 3)  // [1, 2, 3]
val sortedSet = sortedSetOf(3, 1, 2)  // [1, 2, 3]

// 可变集合
val mutableSet = mutableSetOf("a", "b", "a")  // ["a", "b"]
val hashSet = hashSetOf(1.0, 2.0, 1.0)  // 哈希集合

// 带顺序的集合
val linkedSet = linkedSetOf("first", "second", "third")

映射 (Map)

// 只读映射
val map1 = mapOf(1 to "one", 2 to "two")
val map2 = mapOf(Pair("key1", 100), Pair("key2", 200))

// 可变映射
val mutableMap = mutableMapOf("a" to 1, "b" to 2)
val hashMap = hashMapOf("x" to 10, "y" to 20)

// 排序映射
val sortedMap = sortedMapOf(3 to "c", 1 to "a", 2 to "b")  // 按键排序

常用集合操作

1. 转换操作

val numbers = listOf(1, 2, 3, 4, 5)

// 映射
val doubled = numbers.map { it * 2 }  // [2, 4, 6, 8, 10]
val withIndex = numbers.mapIndexed { idx, value -> "$idx: $value" }

// 过滤
val evens = numbers.filter { it % 2 == 0 }  // [2, 4]
val odds = numbers.filterNot { it % 2 == 0 }  // [1, 3, 5]

// 扁平化
val nested = listOf(listOf(1, 2), listOf(3, 4))
val flat = nested.flatten()  // [1, 2, 3, 4]
val flatMapped = nested.flatMap { it.map { num -> num * 2 } }  // [2, 4, 6, 8]

// 分组
val grouped = numbers.groupBy { if (it % 2 == 0) "even" else "odd" }
// {"odd": [1, 3, 5], "even": [2, 4]}

// 分区
val (even, odd) = numbers.partition { it % 2 == 0 }

2. 聚合操作

val numbers = listOf(1, 2, 3, 4, 5)

// 基本聚合
val sum = numbers.sum()  // 15
val avg = numbers.average()  // 3.0
val count = numbers.count()  // 5
val max = numbers.maxOrNull()  // 5

// reduce 和 fold
val product = numbers.reduce { acc, i -> acc * i }  // 120
val sumWithStart = numbers.fold(10) { acc, i -> acc + i }  // 25

// 按条件聚合
val sumOfEvens = numbers.sumOf { if (it % 2 == 0) it else 0 }  // 6

3. 排序操作

val names = listOf("Alice", "Bob", "Charlie", "David")

// 自然排序
val sorted = names.sorted()  // 升序
val sortedDesc = names.sortedDescending()  // 降序

// 自定义排序
val sortedByLength = names.sortedBy { it.length }
val sortedByDesc = names.sortedByDescending { it.last() }

// 带比较器排序
val customSorted = names.sortedWith(
    compareBy<String> { it.length }.thenBy { it }
)

4. 查找和检查

val numbers = listOf(1, 2, 3, 4, 5)

// 元素访问
val first = numbers.first()  // 1
val last = numbers.last()  // 5
val firstEven = numbers.first { it % 2 == 0 }  // 2
val lastOdd = numbers.last { it % 2 == 1 }  // 5

// 安全访问
val firstOrNull = numbers.firstOrNull { it > 10 }  // null
val elementAtOrNull = numbers.elementAtOrNull(10)  // null

// 检查存在
val hasEven = numbers.any { it % 2 == 0 }  // true
val allPositive = numbers.all { it > 0 }  // true
val noneNegative = numbers.none { it < 0 }  // true

// 包含检查
val containsThree = numbers.contains(3)  // true
val containsAll = numbers.containsAll(listOf(1, 3, 5))  // true

5. 集合运算

val set1 = setOf(1, 2, 3, 4)
val set2 = setOf(3, 4, 5, 6)

// 集合运算
val union = set1.union(set2)  // [1, 2, 3, 4, 5, 6]
val intersect = set1.intersect(set2)  // [3, 4]
val subtract = set1.subtract(set2)  // [1, 2]

序列 (Sequences) - 惰性求值

val numbers = (1..1_000_000)

// 普通集合操作（立即求值）
val result1 = numbers
    .filter { it % 2 == 0 }  // 创建中间集合
    .map { it * 2 }           // 创建另一个中间集合
    .take(10)                 // 只取前10个
    .toList()

// 序列操作（惰性求值，更高效）
val result2 = numbers.asSequence()
    .filter { it % 2 == 0 }   // 逐个元素处理
    .map { it * 2 }           // 同上
    .take(10)                 // 处理到第10个就停止
    .toList()

// 创建序列
val sequence1 = sequenceOf(1, 2, 3)
val sequence2 = generateSequence(1) { if (it < 10) it + 1 else null }
val sequence3 = (1..10).asSequence()

集合与数组

// 数组
val array = arrayOf(1, 2, 3)
val intArray = intArrayOf(1, 2, 3)

// 集合转数组
val list = listOf(1, 2, 3)
val arrayFromList = list.toTypedArray()  // Array<Int>
val intArrayFromList = list.toIntArray()  // IntArray

// 数组转集合
val listFromArray = array.toList()
val setFromArray = array.toSet()

可变集合操作

val mutableList = mutableListOf(1, 2, 3)

// 添加元素
mutableList.add(4)
mutableList.addAll(listOf(5, 6))
mutableList += 7  // 运算符重载

// 删除元素
mutableList.remove(2)
mutableList.removeAt(0)
mutableList.removeAll { it % 2 == 0 }
mutableList -= 3  // 运算符重载

// 更新元素
mutableList[0] = 100
mutableList.fill(0)  // 所有元素设为0

// 排序
mutableList.sort()
mutableList.sortByDescending { it }

// 清空
mutableList.clear()

集合转换函数

val list = listOf("apple", "banana", "cherry")

// associate - 转换为 Map
val lengthMap = list.associateWith { it.length }  // {"apple":5, "banana":6...}
val toCharMap = list.associateBy { it.first() }   // {'a':"apple", 'b':"banana"...}

// zip - 合并集合
val numbers = listOf(1, 2, 3)
val zipped = list.zip(numbers)  // [("apple",1), ("banana",2), ("cherry",3)]

// unzip - 解压
val pairs = listOf("a" to 1, "b" to 2, "c" to 3)
val (letters, nums) = pairs.unzip()

// windowed - 滑动窗口
val numbers = (1..5).toList()
val windows = numbers.windowed(3)  // [[1,2,3], [2,3,4], [3,4,5]]

性能考虑和最佳实践

选择合适的数据结构

// 频繁查找 - 使用 Set 或 Map
val set = hashSetOf<String>()  // O(1) 查找

// 频繁索引访问 - 使用 ArrayList
val list = arrayListOf<Int>()  // O(1) 索引访问

// 频繁插入/删除头部 - 考虑 LinkedList
// 注意：Kotlin 标准库没有 LinkedList，需要 Java 的

避免不必要的中间集合

// 不好：创建多个中间集合
val result = list
    .filter { ... }  // 中间集合1
    .map { ... }     // 中间集合2
    .take(10)        // 中间集合3

// 好：使用序列（大数据集时）
val result = list.asSequence()
    .filter { ... }
    .map { ... }
    .take(10)
    .toList()

使用预分配容量

val list = ArrayList<Int>(1000)  // 预分配容量
val map = HashMap<String, Int>(1000)

Java 互操作性

// Kotlin 中使用 Java 集合
val javaList: java.util.ArrayList<String> = java.util.ArrayList()

// Java 中使用 Kotlin 集合
// Kotlin 的 List 在 Java 中会被视为只读
// 如果需要修改，使用 MutableList

// 平台类型转换
@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
val javaList: java.util.List<String> = ...
val kotlinList: List<String> = javaList.toList()  // 转为只读
val mutableList: MutableList<String> = javaList.toMutableList()  // 转为可变

Kotlin 集合框架通过扩展函数提供了丰富的操作，同时保持了与 Java 集合的互操作性，是现代 Android 和 Kotlin 后端开发的强大工具。