集合入门

// 只读集合 —— 接口层面不提供修改方法
val readOnlyList: List<String> = listOf("A", "B", "C")  // 返回只读 List 接口
// readOnlyList.add("D")  // ❌ 编译错误：List 接口没有 add 方法
 
// 可变集合 —— 接口层面提供完整的增删改方法
val mutableList: MutableList<String> = mutableListOf("A", "B", "C")  // 返回 MutableList 接口
mutableList.add("D")  // ✅ 正常编译，列表变为 [A, B, C, D]

// 演示只读视图的本质
val underlying: MutableList<Int> = mutableListOf(1, 2, 3)  // 底层可变列表
val readOnlyView: List<Int> = underlying  // 向上转型为只读接口
 
println(readOnlyView)  // 输出: [1, 2, 3]
underlying.add(4)      // 通过原始引用修改
println(readOnlyView)  // 输出: [1, 2, 3, 4] —— 只读视图也看到了变化！

┌──────────────────────────────────────────────────────────┐
│                                                          │
│   underlying ─────────┬──────► MutableList [1,2,3,4]     │
│   (MutableList<Int>)  │              ▲                   │
│                       │              │                   │
│   readOnlyView ───────┘         底层同一对象              │
│   (List<Int>)                   (same object)            │
│        ↑                                                 │
│   只能读取，不能修改                                       │
│   (read-only interface)                                  │
│                                                          │
└──────────────────────────────────────────────────────────┘

// 基础用法：类型自动推断
val fruits = listOf("Apple", "Banana", "Cherry")  // List<String>
val numbers = listOf(1, 2, 3, 4, 5)               // List<Int>
val mixed = listOf("Hello", 42, 3.14)             // List<Any> —— 混合类型
 
// 显式指定泛型类型
val explicitList: List<Number> = listOf(1, 2.5, 3L)  // Int, Double, Long 都是 Number 子类
 
// 创建空列表 —— 必须显式指定类型
val emptyList1: List<String> = listOf()           // 方式一：空参数
val emptyList2: List<String> = emptyList()        // 方式二：专用函数（推荐，语义更清晰）
 
// 创建单元素列表
val singleItem = listOf("OnlyOne")                // List<String>，包含一个元素

// 查看 listOf 的实际返回类型
val list = listOf(1, 2, 3)
println(list::class)  // 输出: class java.util.Arrays$ArrayList
// 注意：这是 Arrays.asList() 返回的内部类，不是 java.util.ArrayList！
 
// 空列表和单元素列表有特殊优化
val empty = listOf<Int>()
println(empty::class)  // 输出: class kotlin.collections.EmptyList（单例对象）
 
val single = listOf(42)
println(single::class)  // 输出: class java.util.Collections$SingletonList（不可变单例）

// 创建可变列表
val mutableFruits = mutableListOf("Apple", "Banana")  // MutableList<String>
 
// 支持所有修改操作
mutableFruits.add("Cherry")           // 末尾添加 → [Apple, Banana, Cherry]
mutableFruits.add(0, "Apricot")       // 指定位置插入 → [Apricot, Apple, Banana, Cherry]
mutableFruits.remove("Banana")        // 删除元素 → [Apricot, Apple, Cherry]
mutableFruits[1] = "Avocado"          // 修改元素 → [Apricot, Avocado, Cherry]
mutableFruits.removeAt(0)             // 按索引删除 → [Avocado, Cherry]
mutableFruits.clear()                 // 清空列表 → []
 
// 创建空的可变列表
val emptyMutable: MutableList<Int> = mutableListOf()  // 空但可添加元素
emptyMutable.addAll(listOf(1, 2, 3))                  // 批量添加 → [1, 2, 3]

// val 限制的是引用，不是内容！
val fixedReference = mutableListOf(1, 2, 3)
// fixedReference = mutableListOf(4, 5, 6)  // ❌ 编译错误：不能重新赋值
fixedReference.add(4)                        // ✅ 可以修改内容 → [1, 2, 3, 4]
 
// 如果想要完全不可变，使用只读类型 + val
val trulyReadOnly: List<Int> = listOf(1, 2, 3)
// trulyReadOnly.add(4)  // ❌ 编译错误：List 没有 add 方法

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   val fixedRef ──────────► MutableList [1, 2, 3, 4]         │
│        ↑                          ↑                         │
│   引用锁定 (val)              内容可变 (MutableList)          │
│   cannot reassign            can modify content             │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   val readOnly ──────────► List [1, 2, 3]                   │
│        ↑                        ↑                           │
│   引用锁定 (val)            接口只读 (List)                   │
│   cannot reassign          no mutation methods              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// 创建 ArrayList 的几种方式
val arrayList1 = ArrayList<String>()                    // 直接构造，初始容量为 10
val arrayList2 = ArrayList<String>(100)                 // 指定初始容量，避免频繁扩容
val arrayList3 = arrayListOf("A", "B", "C")             // Kotlin 便捷函数
val arrayList4: ArrayList<Int> = ArrayList(listOf(1, 2, 3))  // 从已有集合构造
 
// ArrayList 特有操作
arrayList1.ensureCapacity(50)  // 预分配容量，提升批量添加性能
arrayList1.trimToSize()        // 释放多余容量，节省内存

// ArrayList 扩容演示（概念代码）
val list = ArrayList<Int>(4)  // 初始容量 4
println("初始容量: 4")
 
// 添加元素直到触发扩容
for (i in 1..10) {
    list.add(i)
    // 当 size > capacity 时，新容量 = 旧容量 * 1.5（向下取整）
    // 4 → 6 → 9 → 13 → 19 → ...
}

┌─────────────────────────────────────────────────────────────────┐
│  ArrayList 扩容过程 (Growth Process)                             │
│                                                                 │
│  初始: capacity=4, size=0                                        │
│  ┌───┬───┬───┬───┐                                              │
│  │   │   │   │   │  ← 空数组                                     │
│  └───┴───┴───┴───┘                                              │
│                                                                 │
│  添加 [1,2,3,4] 后: capacity=4, size=4                           │
│  ┌───┬───┬───┬───┐                                              │
│  │ 1 │ 2 │ 3 │ 4 │  ← 已满                                       │
│  └───┴───┴───┴───┘                                              │
│                                                                 │
│  添加第 5 个元素，触发扩容: capacity=6, size=5                     │
│  ┌───┬───┬───┬───┬───┬───┐                                      │
│  │ 1 │ 2 │ 3 │ 4 │ 5 │   │  ← 新数组，旧数据已复制                 │
│  └───┴───┴───┴───┴───┴───┘                                      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

// 创建 LinkedList
val linkedList = LinkedList<String>()  // 需要导入 java.util.LinkedList
linkedList.addAll(listOf("A", "B", "C"))
 
// LinkedList 特有的双端队列操作
linkedList.addFirst("Start")    // 头部添加 → [Start, A, B, C]
linkedList.addLast("End")       // 尾部添加 → [Start, A, B, C, End]
val first = linkedList.removeFirst()  // 移除并返回头部 → "Start"
val last = linkedList.removeLast()    // 移除并返回尾部 → "End"
 
// 作为栈 (Stack) 使用
linkedList.push("Top")          // 等同于 addFirst
val top = linkedList.pop()      // 等同于 removeFirst
 
// 作为队列 (Queue) 使用
linkedList.offer("NewElement")  // 等同于 addLast
val head = linkedList.poll()    // 等同于 removeFirst

import java.util.LinkedList
import kotlin.system.measureTimeMillis
 
fun main() {
    val size = 100_000
    
    // 测试随机访问性能
    val arrayList = ArrayList((0 until size).toList())
    val linkedList = LinkedList((0 until size).toList())
    
    // ArrayList 随机访问：极快
    val arrayTime = measureTimeMillis {
        repeat(10_000) { arrayList[it * 10] }  // 随机读取
    }
    println("ArrayList 随机访问耗时: ${arrayTime}ms")  // 约 1-2ms
    
    // LinkedList 随机访问：很慢
    val linkedTime = measureTimeMillis {
        repeat(10_000) { linkedList[it * 10] }  // 每次都要遍历！
    }
    println("LinkedList 随机访问耗时: ${linkedTime}ms")  // 约 500-1000ms
    
    // 测试头部插入性能
    val arrayInsert = measureTimeMillis {
        val list = ArrayList<Int>()
        repeat(10_000) { list.add(0, it) }  // 每次都要移动所有元素
    }
    println("ArrayList 头部插入耗时: ${arrayInsert}ms")  // 约 50-100ms
    
    val linkedInsert = measureTimeMillis {
        val list = LinkedList<Int>()
        repeat(10_000) { list.addFirst(it) }  // O(1) 操作
    }
    println("LinkedList 头部插入耗时: ${linkedInsert}ms")  // 约 1-2ms
}

val original = mutableListOf(1, 2, 3)
val readOnly: List<Int> = original
original.add(4)
println(readOnly.size)

val fruits = listOf("Apple", "Banana", "Cherry", "Date", "Elderberry")
 
// ===== 基础索引访问 =====
val first = fruits[0]              // "Apple" —— 使用操作符重载，等同于 get(0)
val third = fruits.get(2)          // "Cherry" —— 显式调用 get 方法
// val outOfBounds = fruits[10]    // ❌ 抛出 IndexOutOfBoundsException
 
// ===== 安全访问方法 =====
val safe = fruits.getOrNull(10)    // null —— 越界时返回 null，不抛异常
val withDefault = fruits.getOrElse(10) { "Unknown" }  // "Unknown" —— 越界时执行 lambda 返回默认值
 
// ===== 首尾元素访问 =====
val head = fruits.first()          // "Apple" —— 空列表会抛 NoSuchElementException
val tail = fruits.last()           // "Elderberry"
val safeHead = fruits.firstOrNull() // "Apple" —— 空列表返回 null
val safeTail = fruits.lastOrNull()  // "Elderberry"
 
// ===== 条件访问 =====
val firstLong = fruits.first { it.length > 5 }      // "Banana" —— 第一个长度>5的元素
val lastShort = fruits.last { it.length <= 5 }      // "Date" —— 最后一个长度<=5的元素
val firstMatch = fruits.firstOrNull { it.startsWith("Z") }  // null —— 无匹配时安全返回
 
// ===== 随机访问 =====
val randomFruit = fruits.random()           // 随机返回一个元素
val randomOrNull = emptyList<String>().randomOrNull()  // null —— 空列表安全处理

val numbers = listOf(1, 2, 3, 4, 5)
 
// 解构前几个元素（最多支持 5 个 componentN 函数）
val (a, b, c) = numbers            // a=1, b=2, c=3
val (first, second) = numbers      // first=1, second=2
 
// 配合 _ 忽略不需要的元素
val (_, _, third) = numbers        // third=3，忽略前两个
 
// 实际应用：遍历带索引的列表
for ((index, value) in numbers.withIndex()) {
    println("Index $index -> Value $value")
}

val mutableFruits = mutableListOf("Apple", "Banana", "Cherry")
 
// ===== 添加操作 =====
mutableFruits.add("Date")                    // 末尾添加 → [Apple, Banana, Cherry, Date]
mutableFruits.add(1, "Apricot")              // 指定位置插入 → [Apple, Apricot, Banana, Cherry, Date]
mutableFruits.addAll(listOf("Fig", "Grape")) // 批量添加 → [..., Fig, Grape]
mutableFruits.addAll(2, listOf("X", "Y"))    // 指定位置批量插入
 
// ===== 使用操作符 =====
mutableFruits += "Honeydew"                  // 等同于 add("Honeydew")
mutableFruits += listOf("Kiwi", "Lemon")     // 等同于 addAll(...)
 
// ===== 删除操作 =====
mutableFruits.remove("Banana")               // 按值删除第一个匹配项，返回 Boolean
mutableFruits.removeAt(0)                    // 按索引删除，返回被删除的元素
mutableFruits.removeAll(listOf("X", "Y"))    // 批量删除
mutableFruits.removeIf { it.length > 6 }     // 条件删除：删除所有长度>6的元素
 
// ===== 使用操作符 =====
mutableFruits -= "Cherry"                    // 等同于 remove("Cherry")
mutableFruits -= listOf("Fig", "Grape")      // 等同于 removeAll(...)
 
// ===== 其他修改操作 =====
mutableFruits[0] = "Avocado"                 // 替换指定位置元素
mutableFruits.clear()                        // 清空列表
mutableFruits.retainAll(listOf("A", "B"))    // 只保留指定元素（取交集）

┌────────────────────────────────────────────────────────────────┐
│  ArrayList 操作复杂度 (Time Complexity)                         │
├──────────────────────┬─────────────┬───────────────────────────┤
│  操作                 │  复杂度     │  原因                      │
├──────────────────────┼─────────────┼───────────────────────────┤
│  add(element)        │  O(1)*      │  末尾添加，可能触发扩容      │
│  add(0, element)     │  O(n)       │  头部插入，需移动所有元素    │
│  add(mid, element)   │  O(n)       │  中间插入，需移动后续元素    │
│  removeAt(lastIdx)   │  O(1)       │  末尾删除，无需移动         │
│  removeAt(0)         │  O(n)       │  头部删除，需移动所有元素    │
│  remove(element)     │  O(n)       │  需要先查找元素位置         │
└──────────────────────┴─────────────┴───────────────────────────┘
  * 均摊复杂度 (amortized complexity)

val numbers = listOf(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5)
 
// ===== 存在性判断 =====
val hasThree = 3 in numbers                  // true —— 使用 in 操作符
val hasTen = numbers.contains(10)            // false —— 显式调用
val hasAny = numbers.any { it > 8 }          // true —— 存在任意满足条件的元素
val allPositive = numbers.all { it > 0 }     // true —— 所有元素都满足条件
val noneNegative = numbers.none { it < 0 }   // true —— 没有元素满足条件
 
// ===== 索引查找 =====
val firstIndex = numbers.indexOf(5)          // 4 —— 第一次出现的索引
val lastIndex = numbers.lastIndexOf(5)       // 10 —— 最后一次出现的索引
val notFound = numbers.indexOf(100)          // -1 —— 未找到返回 -1
 
// ===== 条件索引查找 =====
val firstEvenIdx = numbers.indexOfFirst { it % 2 == 0 }   // 2 —— 第一个偶数的索引（值为4）
val lastEvenIdx = numbers.indexOfLast { it % 2 == 0 }     // 7 —— 最后一个偶数的索引（值为6）
 
// ===== 条件元素查找 =====
val firstEven = numbers.find { it % 2 == 0 }              // 4 —— 等同于 firstOrNull
val lastOdd = numbers.findLast { it % 2 == 1 }            // 5 —— 最后一个奇数
 
// ===== 二分查找（仅适用于已排序列表）=====
val sortedList = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
val binaryResult = sortedList.binarySearch(5)             // 4 —— O(log n) 复杂度
val insertionPoint = sortedList.binarySearch(4.5.toInt()) // 负数，表示应插入位置

// ===== 不可变排序（返回新列表）=====
val original = listOf(3, 1, 4, 1, 5, 9, 2, 6)
 
val ascending = original.sorted()                    // [1, 1, 2, 3, 4, 5, 6, 9] —— 升序
val descending = original.sortedDescending()         // [9, 6, 5, 4, 3, 2, 1, 1] —— 降序
val reversed = original.reversed()                   // [6, 2, 9, 5, 1, 4, 1, 3] —— 反转
val shuffled = original.shuffled()                   // 随机打乱顺序
 
// 原列表不变
println(original)  // [3, 1, 4, 1, 5, 9, 2, 6]
 
// ===== 自定义排序 =====
data class Person(val name: String, val age: Int)
val people = listOf(
    Person("Alice", 30),
    Person("Bob", 25),
    Person("Charlie", 35)
)
 
// 按单一属性排序
val byAge = people.sortedBy { it.age }               // Bob(25), Alice(30), Charlie(35)
val byAgeDesc = people.sortedByDescending { it.age } // Charlie(35), Alice(30), Bob(25)
val byName = people.sortedBy { it.name }             // Alice, Bob, Charlie
 
// 使用 Comparator 进行复杂排序
val byAgeAndName = people.sortedWith(
    compareBy({ it.age }, { it.name })               // 先按年龄，再按姓名
)
 
// 自定义 Comparator
val customSort = people.sortedWith { p1, p2 ->
    when {
        p1.age != p2.age -> p1.age - p2.age          // 年龄不同，按年龄升序
        else -> p1.name.compareTo(p2.name)           // 年龄相同，按姓名字母序
    }
}

// ===== 原地排序（修改原列表）=====
val mutableNumbers = mutableListOf(3, 1, 4, 1, 5, 9, 2, 6)
 
mutableNumbers.sort()                                // 原地升序排序
println(mutableNumbers)                              // [1, 1, 2, 3, 4, 5, 6, 9]
 
mutableNumbers.sortDescending()                      // 原地降序排序
mutableNumbers.reverse()                             // 原地反转
mutableNumbers.shuffle()                             // 原地随机打乱
 
// 自定义原地排序
val mutablePeople = mutableListOf(
    Person("Alice", 30),
    Person("Bob", 25)
)
mutablePeople.sortBy { it.age }                      // 原地按年龄排序
mutablePeople.sortByDescending { it.name }           // 原地按姓名降序
mutablePeople.sortWith(compareBy({ it.age }, { it.name }))  // 原地复合排序

┌──────────────────────────────────────────────────────────────────┐
│  排序方法命名规律 (Naming Convention)                              │
├─────────────────────┬────────────────────┬───────────────────────┤
│  返回新列表          │  原地修改           │  说明                  │
│  (Non-mutating)     │  (In-place)        │                       │
├─────────────────────┼────────────────────┼───────────────────────┤
│  sorted()           │  sort()            │  自然升序              │
│  sortedDescending() │  sortDescending()  │  自然降序              │
│  sortedBy {}        │  sortBy {}         │  按属性升序            │
│  sortedByDesc... {} │  sortByDesc... {}  │  按属性降序            │
│  sortedWith()       │  sortWith()        │  自定义 Comparator     │
│  reversed()         │  reverse()         │  反转顺序              │
│  shuffled()         │  shuffle()         │  随机打乱              │
└─────────────────────┴────────────────────┴───────────────────────┘
  规律：带 -ed 后缀的返回新列表，不带的原地修改

val list = listOf(1, 2, 3, 4, 5)
val result = list.getOrElse(10) { index -> index * 2 }
println(result)

// 基础创建
val fruits = setOf("Apple", "Banana", "Cherry")      // Set<String>
val numbers = setOf(1, 2, 3, 4, 5)                   // Set<Int>
 
// 自动去重 —— Set 的核心特性
val withDuplicates = setOf(1, 2, 2, 3, 3, 3)
println(withDuplicates)                              // [1, 2, 3] —— 重复元素被自动移除
println(withDuplicates.size)                         // 3
 
// 空 Set
val emptySet1: Set<String> = setOf()                 // 空参数方式
val emptySet2: Set<String> = emptySet()              // 推荐：语义更清晰
 
// 元素顺序 —— setOf 默认保持插入顺序（底层是 LinkedHashSet）
val ordered = setOf("C", "A", "B")
println(ordered)                                     // [C, A, B] —— 保持插入顺序

// Set 判断元素相等使用 equals() 和 hashCode()
data class Person(val name: String, val age: Int)
 
val set = setOf(
    Person("Alice", 30),
    Person("Alice", 30),                             // 重复！data class 自动生成 equals
    Person("Bob", 25)
)
println(set.size)                                    // 2 —— 只有 Alice 和 Bob
 
// 非 data class 需要手动重写 equals/hashCode
class SimpleClass(val value: Int)
val simpleSet = setOf(
    SimpleClass(1),
    SimpleClass(1)                                   // 不会去重！默认比较引用
)
println(simpleSet.size)                              // 2 —— 两个不同的对象

val mutableFruits = mutableSetOf("Apple", "Banana")
 
// 添加元素
val added1 = mutableFruits.add("Cherry")             // true —— 添加成功
val added2 = mutableFruits.add("Apple")              // false —— 已存在，添加失败
println(mutableFruits)                               // [Apple, Banana, Cherry]
 
// 批量添加
mutableFruits.addAll(listOf("Date", "Apple", "Fig")) // Apple 不会重复添加
println(mutableFruits)                               // [Apple, Banana, Cherry, Date, Fig]
 
// 删除元素
mutableFruits.remove("Banana")                       // 删除指定元素
mutableFruits.removeIf { it.length > 5 }             // 条件删除：删除 Cherry、Banana
mutableFruits.clear()                                // 清空
 
// 操作符支持
mutableFruits += "Grape"                             // 等同于 add
mutableFruits += setOf("Honeydew", "Kiwi")           // 等同于 addAll
mutableFruits -= "Grape"                             // 等同于 remove

// 创建 HashSet
val hashSet = HashSet<String>()                      // 直接构造
val hashSet2 = hashSetOf("A", "B", "C")              // Kotlin 便捷函数
val hashSet3 = HashSet(listOf("X", "Y", "Z"))        // 从集合构造
 
// 性能特点演示
hashSet.add("Element")                               // O(1) 平均
hashSet.contains("Element")                          // O(1) 平均
hashSet.remove("Element")                            // O(1) 平均
 
// 顺序不保证
val unordered = hashSetOf("C", "A", "B", "D")
println(unordered)                                   // 顺序可能是 [A, B, C, D] 或其他
// 每次运行结果可能不同！

┌─────────────────────────────────────────────────────────────────┐
│  HashSet 内部结构 (Internal Structure)                           │
│                                                                 │
│  元素 "Apple" → hashCode() = 63476538                           │
│                     ↓                                           │
│              桶索引 = hash % 容量 = 63476538 % 16 = 10           │
│                     ↓                                           │
│  ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐              │
│  │  0  │  1  │  2  │ ... │ 10  │ 11  │ ... │ 15  │  ← 桶数组     │
│  └─────┴─────┴─────┴─────┴──┬──┴─────┴─────┴─────┘              │
│                             │                                   │
│                             ▼                                   │
│                        ["Apple"]  ← 存储在桶 10                  │
│                             │                                   │
│                             ▼                                   │
│                     [其他hash冲突元素]  ← 链表/红黑树处理冲突       │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

// 创建 LinkedHashSet
val linkedSet = LinkedHashSet<String>()
val linkedSet2 = linkedSetOf("C", "A", "B")          // Kotlin 便捷函数
 
// 保持插入顺序
linkedSet.add("Third")
linkedSet.add("First")
linkedSet.add("Second")
println(linkedSet)                                   // [Third, First, Second] —— 插入顺序
 
// 遍历顺序稳定
linkedSet.forEach { println(it) }                    // 始终按插入顺序输出
 
// 性能：与 HashSet 相同的 O(1) 操作，但略有额外内存开销

val defaultSet = setOf("A", "B", "C")
println(defaultSet::class)                           // class java.util.LinkedHashSet
// Kotlin 的 setOf 默认保持插入顺序，这是一个实用的设计决策

import java.util.TreeSet
 
// 创建 TreeSet —— 元素自动排序
val treeSet = TreeSet<Int>()
treeSet.addAll(listOf(5, 2, 8, 1, 9, 3))
println(treeSet)                                     // [1, 2, 3, 5, 8, 9] —— 自动升序
 
// 字符串按字典序排序
val stringTree = TreeSet<String>()
stringTree.addAll(listOf("Banana", "Apple", "Cherry"))
println(stringTree)                                  // [Apple, Banana, Cherry]
 
// 自定义排序规则
val descending = TreeSet<Int>(reverseOrder())        // 降序比较器
descending.addAll(listOf(1, 5, 3, 9, 2))
println(descending)                                  // [9, 5, 3, 2, 1]
 
// 自定义对象排序
data class Person(val name: String, val age: Int)
val personTree = TreeSet<Person>(compareBy { it.age })
personTree.add(Person("Alice", 30))
personTree.add(Person("Bob", 25))
personTree.add(Person("Charlie", 35))
println(personTree)                                  // 按年龄排序：Bob, Alice, Charlie
 
// TreeSet 特有的导航方法
val numbers = TreeSet(listOf(1, 3, 5, 7, 9))
println(numbers.first())                             // 1 —— 最小元素
println(numbers.last())                              // 9 —— 最大元素
println(numbers.lower(5))                            // 3 —— 小于 5 的最大元素
println(numbers.higher(5))                           // 7 —— 大于 5 的最小元素
println(numbers.floor(6))                            // 5 —— 小于等于 6 的最大元素
println(numbers.ceiling(6))                          // 7 —— 大于等于 6 的最小元素
println(numbers.headSet(5))                          // [1, 3] —— 小于 5 的子集
println(numbers.tailSet(5))                          // [5, 7, 9] —— 大于等于 5 的子集

val fruits = mutableSetOf("Apple", "Banana", "Cherry")
 
// ===== 添加操作 =====
val added1 = fruits.add("Date")              // true —— 新元素，添加成功
val added2 = fruits.add("Apple")             // false —— 已存在，添加失败（Set 不允许重复）
println(fruits)                              // [Apple, Banana, Cherry, Date]
 
// 批量添加 —— 返回是否有任何元素被添加
val anyAdded = fruits.addAll(listOf("Fig", "Apple", "Grape"))  // true
println(fruits)                              // [Apple, Banana, Cherry, Date, Fig, Grape]
 
// 操作符方式
fruits += "Honeydew"                         // 等同于 add()
fruits += setOf("Kiwi", "Lemon")             // 等同于 addAll()
 
// ===== 删除操作 =====
val removed1 = fruits.remove("Banana")       // true —— 存在，删除成功
val removed2 = fruits.remove("Mango")        // false —— 不存在，删除失败
println(fruits)                              // [Apple, Cherry, Date, Fig, Grape, Honeydew, Kiwi, Lemon]
 
// 批量删除
fruits.removeAll(listOf("Date", "Fig", "NotExist"))  // 删除存在的元素
println(fruits)                              // [Apple, Cherry, Grape, Honeydew, Kiwi, Lemon]
 
// 条件删除
fruits.removeIf { it.length > 5 }            // 删除长度大于5的元素
println(fruits)                              // [Apple, Grape, Kiwi, Lemon]
 
// 保留指定元素（取交集）
fruits.retainAll(listOf("Apple", "Kiwi", "Mango"))  // 只保留列表中存在的
println(fruits)                              // [Apple, Kiwi]
 
// 操作符方式删除
fruits -= "Apple"                            // 等同于 remove()
fruits -= setOf("Kiwi", "NotExist")          // 等同于 removeAll()
 
// 清空
fruits.clear()
println(fruits.isEmpty())                    // true

// 利用 add() 返回值判断元素是否为新元素
val processedIds = mutableSetOf<Int>()
 
fun processItem(id: Int): Boolean {
    // 如果是新 ID，处理它；如果已处理过，跳过
    if (processedIds.add(id)) {
        println("Processing new item: $id")  // 首次处理
        return true
    } else {
        println("Item $id already processed, skipping")  // 重复跳过
        return false
    }
}
 
processItem(1)  // Processing new item: 1
processItem(2)  // Processing new item: 2
processItem(1)  // Item 1 already processed, skipping

val setA = setOf(1, 2, 3, 4, 5)
val setB = setOf(4, 5, 6, 7, 8)
 
// ===== 并集 (Union) =====
// 包含两个集合中所有元素，自动去重
val union1 = setA union setB                 // 中缀函数写法
val union2 = setA.union(setB)                // 标准函数写法
val union3 = setA + setB                     // 操作符写法（推荐）
println(union1)                              // [1, 2, 3, 4, 5, 6, 7, 8]
 
// ===== 交集 (Intersection) =====
// 只包含两个集合中都存在的元素
val intersect1 = setA intersect setB         // 中缀函数写法
val intersect2 = setA.intersect(setB)        // 标准函数写法
println(intersect1)                          // [4, 5]
 
// ===== 差集 (Difference / Subtract) =====
// 包含在第一个集合中但不在第二个集合中的元素
val subtract1 = setA subtract setB           // 中缀函数写法：A - B
val subtract2 = setA.subtract(setB)          // 标准函数写法
val subtract3 = setA - setB                  // 操作符写法（推荐）
println(subtract1)                           // [1, 2, 3] —— 在 A 中但不在 B 中
 
val subtractReverse = setB - setA            // B - A
println(subtractReverse)                     // [6, 7, 8] —— 在 B 中但不在 A 中
 
// ===== 对称差集 (Symmetric Difference) =====
// 只在其中一个集合中出现的元素（并集 - 交集）
val symmetricDiff = (setA union setB) - (setA intersect setB)
// 或者更直观的写法
val symmetricDiff2 = (setA - setB) + (setB - setA)
println(symmetricDiff)                       // [1, 2, 3, 6, 7, 8]

┌─────────────────────────────────────────────────────────────────┐
│  集合运算图解 (Set Operations Visualization)                      │
│                                                                 │
│       setA = {1,2,3,4,5}        setB = {4,5,6,7,8}              │
│                                                                 │
│            ┌───────┐               ┌───────┐                    │
│            │ 1 2 3 │───────────────│ 6 7 8 │                    │
│            │       │   4   5       │       │                    │
│            │   A   │───────────────│   B   │                    │
│            └───────┘   (交集)       └───────┘                    │
│                                                                 │
│  并集 (A ∪ B):     {1, 2, 3, 4, 5, 6, 7, 8}  ← 所有元素          │
│  交集 (A ∩ B):     {4, 5}                    ← 共同元素          │
│  差集 (A - B):     {1, 2, 3}                 ← A 独有            │
│  差集 (B - A):     {6, 7, 8}                 ← B 独有            │
│  对称差 (A △ B):   {1, 2, 3, 6, 7, 8}        ← 非共同元素        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

// 场景1：找出新增用户和流失用户
val yesterdayUsers = setOf("Alice", "Bob", "Charlie", "David")
val todayUsers = setOf("Bob", "Charlie", "Eve", "Frank")
 
val newUsers = todayUsers - yesterdayUsers       // 新增：[Eve, Frank]
val lostUsers = yesterdayUsers - todayUsers      // 流失：[Alice, David]
val retainedUsers = yesterdayUsers intersect todayUsers  // 留存：[Bob, Charlie]
 
// 场景2：权限合并
val adminPermissions = setOf("read", "write", "delete", "admin")
val userPermissions = setOf("read", "write")
 
val allPermissions = adminPermissions union userPermissions  // 合并权限
val adminOnlyPermissions = adminPermissions - userPermissions  // 管理员独有：[delete, admin]
 
// 场景3：标签去重合并
val articleTags = setOf("Kotlin", "Android", "JVM")
val videoTags = setOf("Kotlin", "Tutorial", "Beginner")
val allTags = articleTags + videoTags            // [Kotlin, Android, JVM, Tutorial, Beginner]

val numbers = setOf(1, 2, 3, 4, 5)
val subset = setOf(2, 3)
val other = setOf(6, 7, 8)
 
// ===== 元素存在性判断 =====
val hasThree = 3 in numbers                  // true —— in 操作符（推荐）
val hasTen = numbers.contains(10)            // false —— 显式调用
val hasAnyEven = numbers.any { it % 2 == 0 } // true —— 存在偶数
val allPositive = numbers.all { it > 0 }     // true —— 全部为正数
val noneNegative = numbers.none { it < 0 }   // true —— 没有负数
 
// ===== 集合关系判断 =====
// 子集判断：subset 的所有元素是否都在 numbers 中
val isSubset = numbers.containsAll(subset)   // true —— {2,3} ⊆ {1,2,3,4,5}
 
// 判断两个集合是否有交集
val hasCommon = (numbers intersect other).isNotEmpty()  // false
val noCommon = (numbers intersect other).isEmpty()      // true —— 无交集
 
// 判断两个集合是否相等（元素完全相同，顺序无关）
val setX = setOf(1, 2, 3)
val setY = setOf(3, 2, 1)
val setZ = setOf(1, 2, 3, 4)
println(setX == setY)                        // true —— 元素相同即相等
println(setX == setZ)                        // false —— 元素不同
 
// ===== 空集判断 =====
val emptySet = emptySet<Int>()
println(emptySet.isEmpty())                  // true
println(emptySet.isNotEmpty())               // false
println(numbers.isNotEmpty())                // true

// 自定义扩展函数实现更多集合关系判断
// 真子集判断：A 是 B 的子集，且 A ≠ B
infix fun <T> Set<T>.isProperSubsetOf(other: Set<T>): Boolean {
    return this != other && other.containsAll(this)
}
 
// 超集判断：A 包含 B 的所有元素
infix fun <T> Set<T>.isSupersetOf(other: Set<T>): Boolean {
    return this.containsAll(other)
}
 
// 使用示例
val small = setOf(1, 2)
val large = setOf(1, 2, 3, 4, 5)
 
println(small isProperSubsetOf large)        // true —— {1,2} ⊂ {1,2,3,4,5}
println(large isSupersetOf small)            // true —— {1,2,3,4,5} ⊇ {1,2}
println(small isProperSubsetOf small)        // false —— 不是真子集

val setA = setOf(1, 2, 3, 4)
val setB = setOf(3, 4, 5, 6)
val result = (setA - setB) + (setB - setA)
println(result.size)

// ===== 基础创建方式 =====
// 使用 to 中缀函数创建 Pair（推荐，可读性最好）
val capitals = mapOf(
    "China" to "Beijing",
    "Japan" to "Tokyo",
    "Korea" to "Seoul"
)
 
// 使用 Pair 构造函数（等价写法）
val capitals2 = mapOf(
    Pair("China", "Beijing"),
    Pair("Japan", "Tokyo")
)
 
// 类型推断
val scores: Map<String, Int> = mapOf(
    "Alice" to 95,
    "Bob" to 87,
    "Charlie" to 92
)
 
// ===== 空 Map =====
val emptyMap1: Map<String, Int> = mapOf()    // 空参数
val emptyMap2: Map<String, Int> = emptyMap() // 推荐：语义更清晰
 
// ===== 键的唯一性 =====
// 如果有重复的键，后面的值会覆盖前面的
val duplicateKeys = mapOf(
    "key" to "first",
    "key" to "second"                        // 覆盖前面的值
)
println(duplicateKeys)                       // {key=second}
println(duplicateKeys.size)                  // 1

val userAges = mapOf("Alice" to 30, "Bob" to 25, "Charlie" to 35)
 
// 基本属性
println(userAges.size)                       // 3 —— 键值对数量
println(userAges.isEmpty())                  // false
println(userAges.isNotEmpty())               // true
 
// 获取所有键、值、条目
println(userAges.keys)                       // [Alice, Bob, Charlie] —— Set<String>
println(userAges.values)                     // [30, 25, 35] —— Collection<Int>
println(userAges.entries)                    // [Alice=30, Bob=25, Charlie=35] —— Set<Entry>
 
// mapOf 默认保持插入顺序（底层是 LinkedHashMap）
val ordered = mapOf("C" to 3, "A" to 1, "B" to 2)
println(ordered.keys)                        // [C, A, B] —— 保持插入顺序

val mutableScores = mutableMapOf("Alice" to 95, "Bob" to 87)
 
// ===== 添加/修改操作 =====
mutableScores["Charlie"] = 92                // 添加新键值对
mutableScores["Alice"] = 98                  // 修改已有键的值
mutableScores.put("David", 88)               // put 方法，返回旧值或 null
println(mutableScores)                       // {Alice=98, Bob=87, Charlie=92, David=88}
 
// 批量添加
mutableScores.putAll(mapOf("Eve" to 91, "Frank" to 85))
mutableScores += mapOf("Grace" to 93)        // 操作符方式
 
// 仅当键不存在时添加
val oldValue = mutableScores.putIfAbsent("Alice", 100)  // 返回 98，不修改
val newValue = mutableScores.putIfAbsent("Henry", 89)   // 返回 null，添加成功
 
// ===== 删除操作 =====
mutableScores.remove("Bob")                  // 按键删除，返回被删除的值或 null
mutableScores.remove("Alice", 98)            // 仅当键值都匹配时删除，返回 Boolean
mutableScores -= "Charlie"                   // 操作符方式
mutableScores -= listOf("David", "Eve")      // 批量删除
 
// 条件删除（Java 8+ 方法）
mutableScores.entries.removeIf { it.value < 90 }  // 删除分数低于90的
 
// 清空
mutableScores.clear()

val map = mutableMapOf("key" to "oldValue")
 
// 索引操作符：简洁，无返回值
map["key"] = "newValue"
 
// put 方法：返回旧值，适合需要知道是否覆盖的场景
val previous = map.put("key", "anotherValue")  // 返回 "newValue"
println(previous)                              // newValue
 
// 实际应用：统计词频
val wordCount = mutableMapOf<String, Int>()
val words = listOf("apple", "banana", "apple", "cherry", "apple")
 
for (word in words) {
    val count = wordCount.put(word, (wordCount[word] ?: 0) + 1)
    // count 是旧值，可用于判断是否是首次出现
}
println(wordCount)                             // {apple=3, banana=1, cherry=1}

// 创建 HashMap
val hashMap = HashMap<String, Int>()         // 直接构造
val hashMap2 = hashMapOf("A" to 1, "B" to 2) // Kotlin 便捷函数
val hashMap3 = HashMap(mapOf("X" to 10))     // 从已有 Map 构造
 
// 指定初始容量和负载因子（性能优化）
val optimized = HashMap<String, Int>(100, 0.75f)
// 初始容量 100：预期存储约 100 个元素时，避免频繁扩容
// 负载因子 0.75：当元素数量达到容量的 75% 时触发扩容
 
// 性能特点
hashMap["key"] = 100                         // O(1) 平均
val value = hashMap["key"]                   // O(1) 平均
hashMap.remove("key")                        // O(1) 平均
hashMap.containsKey("key")                   // O(1) 平均
hashMap.containsValue(100)                   // O(n) —— 需要遍历所有值！
 
// 顺序不保证
val unordered = hashMapOf("C" to 3, "A" to 1, "B" to 2)
println(unordered.keys)                      // 顺序可能是 [A, B, C] 或其他任意顺序

// 创建 LinkedHashMap（默认保持插入顺序）
val linkedMap = LinkedHashMap<String, Int>()
val linkedMap2 = linkedMapOf("C" to 3, "A" to 1, "B" to 2)
 
// 保持插入顺序
linkedMap["Third"] = 3
linkedMap["First"] = 1
linkedMap["Second"] = 2
println(linkedMap.keys)                      // [Third, First, Second] —— 插入顺序
 
// mapOf 默认返回 LinkedHashMap
val defaultMap = mapOf("C" to 3, "A" to 1, "B" to 2)
println(defaultMap::class)                   // class java.util.LinkedHashMap
 
// ===== 访问顺序模式（LRU 缓存基础）=====
// 第三个参数 accessOrder = true 启用访问顺序
val accessOrderMap = LinkedHashMap<String, Int>(16, 0.75f, true)
accessOrderMap["A"] = 1
accessOrderMap["B"] = 2
accessOrderMap["C"] = 3
println(accessOrderMap.keys.toList())        // [A, B, C]
 
accessOrderMap["A"]                          // 访问 A，A 移到末尾
println(accessOrderMap.keys.toList())        // [B, C, A]
 
accessOrderMap["B"] = 20                     // 修改 B，B 移到末尾
println(accessOrderMap.keys.toList())        // [C, A, B]

// LRU (Least Recently Used) 缓存：淘汰最久未使用的元素
class LRUCache<K, V>(private val maxSize: Int) : LinkedHashMap<K, V>(maxSize, 0.75f, true) {
    
    // 重写此方法，当返回 true 时自动删除最老的条目
    override fun removeEldestEntry(eldest: MutableMap.MutableEntry<K, V>?): Boolean {
        return size > maxSize
    }
}
 
// 使用示例
val cache = LRUCache<String, String>(3)      // 最多缓存 3 个元素
cache["A"] = "Apple"
cache["B"] = "Banana"
cache["C"] = "Cherry"
println(cache.keys)                          // [A, B, C]
 
cache["D"] = "Date"                          // 添加第 4 个，自动淘汰最老的 A
println(cache.keys)                          // [B, C, D]
 
cache["B"]                                   // 访问 B，B 变成最新
cache["E"] = "Elderberry"                    // 添加第 5 个，淘汰最老的 C
println(cache.keys)                          // [D, B, E]

import java.util.TreeMap
 
// 创建 TreeMap —— 键自动排序
val treeMap = TreeMap<String, Int>()
treeMap["Banana"] = 2
treeMap["Apple"] = 1
treeMap["Cherry"] = 3
println(treeMap.keys)                        // [Apple, Banana, Cherry] —— 字典序
 
// 数字键排序
val numberMap = TreeMap<Int, String>()
numberMap[3] = "Three"
numberMap[1] = "One"
numberMap[2] = "Two"
println(numberMap.keys)                      // [1, 2, 3] —— 自然升序
 
// 自定义排序（降序）
val descMap = TreeMap<Int, String>(reverseOrder())
descMap.putAll(mapOf(1 to "One", 3 to "Three", 2 to "Two"))
println(descMap.keys)                        // [3, 2, 1] —— 降序
 
// ===== TreeMap 特有的导航方法 =====
val scores = TreeMap(mapOf(60 to "D", 70 to "C", 80 to "B", 90 to "A"))
 
// 查找相邻键
println(scores.firstKey())                   // 60 —— 最小键
println(scores.lastKey())                    // 90 —— 最大键
println(scores.lowerKey(80))                 // 70 —— 小于 80 的最大键
println(scores.higherKey(80))                // 90 —— 大于 80 的最小键
println(scores.floorKey(85))                 // 80 —— 小于等于 85 的最大键
println(scores.ceilingKey(85))               // 90 —— 大于等于 85 的最小键
 
// 范围查询
println(scores.headMap(80))                  // {60=D, 70=C} —— 键 < 80
println(scores.tailMap(80))                  // {80=B, 90=A} —— 键 >= 80
println(scores.subMap(70, 90))               // {70=C, 80=B} —— 70 <= 键 < 90
 
// 获取首尾条目
println(scores.firstEntry())                 // 60=D
println(scores.lastEntry())                  // 90=A
println(scores.pollFirstEntry())             // 60=D —— 移除并返回最小条目
println(scores)                              // {70=C, 80=B, 90=A}

val userScores = mapOf(
    "Alice" to 95,
    "Bob" to 87,
    "Charlie" to 92
)
 
// ===== 基础访问方式 =====
val aliceScore = userScores["Alice"]         // 95 —— 返回 Int?（可空类型）
val unknownScore = userScores["Unknown"]     // null —— 键不存在返回 null
val bobScore = userScores.get("Bob")         // 87 —— 等同于 [] 操作符
 
// ===== 安全访问方式 =====
// getValue：键不存在时抛出 NoSuchElementException
val mustExist = userScores.getValue("Alice") // 95 —— 返回非空 Int
// val crash = userScores.getValue("Unknown") // ❌ 抛出异常
 
// getOrDefault：键不存在时返回默认值
val withDefault = userScores.getOrDefault("Unknown", 0)  // 0
val existing = userScores.getOrDefault("Alice", 0)       // 95 —— 键存在则返回实际值
 
// getOrElse：键不存在时执行 lambda 计算默认值
val computed = userScores.getOrElse("Unknown") { 
    println("Computing default...")          // 仅在键不存在时执行
    -1 
}  // -1
 
// ===== 存在性检查 =====
val hasAlice = "Alice" in userScores         // true —— in 操作符（推荐）
val hasBob = userScores.containsKey("Bob")   // true —— 显式方法
val hasScore95 = userScores.containsValue(95) // true —— 检查值是否存在（O(n)）
 
// ===== 空安全处理模式 =====
// 模式1：使用 Elvis 操作符
val score1 = userScores["Unknown"] ?: 0      // 0
 
// 模式2：使用 let 进行非空处理
userScores["Alice"]?.let { score ->
    println("Alice's score is $score")       // 仅当值非空时执行
}
 
// 模式3：结合空检查
val score2 = if ("Unknown" in userScores) {
    userScores["Unknown"]!!                  // 已确认存在，安全使用 !!
} else {
    0
}

┌────────────────────────────────────────────────────────────────────┐
│  Map 访问方法对比 (Access Methods Comparison)                        │
├──────────────────┬─────────────────┬───────────────────────────────┤
│  方法             │  键不存在时      │  适用场景                      │
├──────────────────┼─────────────────┼───────────────────────────────┤
│  map[key]        │  返回 null      │  通用访问，需处理 null          │
│  map.getValue()  │  抛出异常       │  确定键存在，或希望快速失败       │
│  map.getOrDefault│  返回默认值     │  有固定默认值                   │
│  map.getOrElse   │  执行 lambda   │  默认值需要计算                  │
│  key in map      │  返回 false    │  仅检查存在性                    │
└──────────────────┴─────────────────┴───────────────────────────────┘

val mutableScores = mutableMapOf("Alice" to 95, "Bob" to 87)
 
// ===== 添加与修改 =====
// 方式1：索引操作符（最常用）
mutableScores["Charlie"] = 92                // 添加新键值对
mutableScores["Alice"] = 98                  // 修改已有键的值
 
// 方式2：put 方法（返回旧值）
val oldBob = mutableScores.put("Bob", 90)    // 返回 87（旧值）
val oldNew = mutableScores.put("David", 88)  // 返回 null（新键）
 
// 方式3：批量添加
mutableScores.putAll(mapOf("Eve" to 91, "Frank" to 85))
mutableScores += mapOf("Grace" to 93, "Henry" to 89)  // 操作符方式
mutableScores += "Ivy" to 94                 // 添加单个 Pair
 
// ===== 条件添加/修改 =====
// putIfAbsent：仅当键不存在时添加
val result1 = mutableScores.putIfAbsent("Alice", 100)  // 返回 98，不修改
val result2 = mutableScores.putIfAbsent("Jack", 86)    // 返回 null，添加成功
 
// getOrPut：获取值，若不存在则计算并存入（非常实用！）
val aliceScore = mutableScores.getOrPut("Alice") { 0 }  // 返回 98（已存在）
val newScore = mutableScores.getOrPut("Kate") { 
    println("Computing Kate's score...")
    calculateScore()                         // 仅在键不存在时执行
}
 
// compute 系列方法（Java 8+）
mutableScores.compute("Alice") { _, oldValue -> 
    (oldValue ?: 0) + 5                      // 基于旧值计算新值
}
 
// ===== 删除操作 =====
// 按键删除
val removedValue = mutableScores.remove("Bob")  // 返回被删除的值 90，或 null
mutableScores -= "Charlie"                   // 操作符方式
mutableScores -= listOf("David", "Eve")      // 批量删除
 
// 条件删除：仅当键值都匹配时删除
val removed = mutableScores.remove("Alice", 103)  // false —— 值不匹配，不删除
val removed2 = mutableScores.remove("Alice", 103) // 需要键值都匹配
 
// 清空
mutableScores.clear()

// 场景1：分组统计
val words = listOf("apple", "banana", "apple", "cherry", "banana", "apple")
val wordCount = mutableMapOf<String, Int>()
 
for (word in words) {
    // 传统写法
    // wordCount[word] = (wordCount[word] ?: 0) + 1
    
    // 使用 getOrPut（更优雅）
    wordCount[word] = wordCount.getOrPut(word) { 0 } + 1
}
println(wordCount)  // {apple=3, banana=2, cherry=1}
 
// 场景2：构建邻接表
val edges = listOf("A" to "B", "A" to "C", "B" to "C", "C" to "D")
val adjacencyList = mutableMapOf<String, MutableList<String>>()
 
for ((from, to) in edges) {
    adjacencyList.getOrPut(from) { mutableListOf() }.add(to)
}
println(adjacencyList)  // {A=[B, C], B=[C], C=[D]}
 
// 场景3：缓存计算结果
val cache = mutableMapOf<Int, Long>()
fun fibonacci(n: Int): Long = cache.getOrPut(n) {
    if (n <= 1) n.toLong() else fibonacci(n - 1) + fibonacci(n - 2)
}

val capitals = mapOf(
    "China" to "Beijing",
    "Japan" to "Tokyo",
    "Korea" to "Seoul",
    "Thailand" to "Bangkok"
)
 
// ===== 遍历条目 (entries) =====
// 方式1：解构声明（最推荐）
for ((country, capital) in capitals) {
    println("$country -> $capital")
}
 
// 方式2：显式访问 entries
for (entry in capitals.entries) {
    println("${entry.key} -> ${entry.value}")
}
 
// 方式3：forEach 高阶函数
capitals.forEach { (country, capital) ->
    println("$country -> $capital")
}
 
// 方式4：带索引遍历
capitals.entries.forEachIndexed { index, (country, capital) ->
    println("$index: $country -> $capital")
}
 
// ===== 遍历键 (keys) =====
for (country in capitals.keys) {
    println("Country: $country")
}
 
// 使用键访问值
capitals.keys.forEach { country ->
    val capital = capitals[country]          // 额外的查找操作
    println("$country -> $capital")
}
 
// ===== 遍历值 (values) =====
for (capital in capitals.values) {
    println("Capital: $capital")
}
 
// 值的聚合操作
val allCapitals = capitals.values.joinToString(", ")
println(allCapitals)                         // Beijing, Tokyo, Seoul, Bangkok
 
// ===== 函数式遍历 =====
// map 转换
val descriptions = capitals.map { (country, capital) ->
    "The capital of $country is $capital"
}
 
// filter 过滤
val longNames = capitals.filter { (country, _) -> 
    country.length > 5 
}
println(longNames)                           // {Thailand=Bangkok}
 
// filterKeys / filterValues
val startsWithC = capitals.filterKeys { it.startsWith("C") }
val startsWithB = capitals.filterValues { it.startsWith("B") }

val map = mapOf("A" to 1, "B" to 2, "C" to 3)
 
// entries: Set<Map.Entry<K, V>> —— 键值对的集合
val entries: Set<Map.Entry<String, Int>> = map.entries
println(entries::class)                      // LinkedEntrySet
 
// keys: Set<K> —— 键的集合（与 Map 共享数据）
val keys: Set<String> = map.keys
println(keys::class)                         // LinkedKeySet
 
// values: Collection<V> —— 值的集合（可能有重复）
val values: Collection<Int> = map.values
println(values::class)                       // LinkedValues
 
// 注意：这些都是视图，不是副本！
val mutableMap = mutableMapOf("A" to 1, "B" to 2)
val keysView = mutableMap.keys
println(keysView)                            // [A, B]
mutableMap["C"] = 3
println(keysView)                            // [A, B, C] —— 视图自动更新

┌─────────────────────────────────────────────────────────────────┐
│  Map 视图关系 (Map Views Relationship)                           │
│                                                                 │
│                    ┌─────────────────────┐                      │
│                    │       Map           │                      │
│                    │  {A=1, B=2, C=3}    │                      │
│                    └─────────┬───────────┘                      │
│                              │                                  │
│           ┌──────────────────┼──────────────────┐               │
│           │                  │                  │               │
│           ▼                  ▼                  ▼               │
│    ┌──────────┐      ┌──────────────┐    ┌──────────┐          │
│    │   keys   │      │   entries    │    │  values  │          │
│    │ Set<K>   │      │ Set<Entry>   │    │ Coll<V>  │          │
│    │ [A,B,C]  │      │ [A=1,B=2,C=3]│    │ [1,2,3]  │          │
│    └──────────┘      └──────────────┘    └──────────┘          │
│         ↑                   ↑                  ↑                │
│         └───────────────────┴──────────────────┘                │
│                    都是视图，共享底层数据                          │
│                   (Views, sharing underlying data)              │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

val config = mapOf(
    "timeout" to 30,
    "retries" to 3,
    "debug" to 0
)
 
// ===== getOrDefault =====
// 键存在：返回实际值
val timeout = config.getOrDefault("timeout", 60)     // 30
// 键不存在：返回默认值
val maxConn = config.getOrDefault("maxConnections", 100)  // 100
 
// ===== getOrElse =====
// 与 getOrDefault 类似，但默认值通过 lambda 计算
val computed = config.getOrElse("unknown") {
    println("Computing default value...")    // 仅在键不存在时执行
    calculateDefault()
}
 
// 区别：getOrDefault 的默认值总是会被求值
val expensive = config.getOrDefault("timeout", expensiveCalculation())  // 即使键存在也会计算
val lazy = config.getOrElse("timeout") { expensiveCalculation() }       // 键存在则不计算
 
// ===== withDefault =====
// 创建一个带默认值的 Map 视图
val configWithDefault = config.withDefault { key ->
    when (key) {
        "maxConnections" -> 100
        "bufferSize" -> 1024
        else -> -1
    }
}
 
// 使用 getValue 访问（不会返回 null）
val maxConn2 = configWithDefault.getValue("maxConnections")  // 100
val buffer = configWithDefault.getValue("bufferSize")        // 1024
val unknown = configWithDefault.getValue("whatever")         // -1
 
// 注意：普通 [] 访问仍然返回 null
val stillNull = configWithDefault["maxConnections"]          // null（键确实不存在）

// 场景1：配置读取
data class AppConfig(
    val timeout: Int,
    val retries: Int,
    val debug: Boolean
)
 
fun loadConfig(props: Map<String, Any>): AppConfig {
    return AppConfig(
        timeout = (props.getOrDefault("timeout", 30) as Number).toInt(),
        retries = (props.getOrDefault("retries", 3) as Number).toInt(),
        debug = props.getOrDefault("debug", false) as Boolean
    )
}
 
// 场景2：统计计数
fun countOccurrences(items: List<String>): Map<String, Int> {
    val counts = mutableMapOf<String, Int>()
    for (item in items) {
        counts[item] = counts.getOrDefault(item, 0) + 1
    }
    return counts
}
 
// 场景3：多级 Map 安全访问
val nestedMap = mapOf(
    "level1" to mapOf(
        "level2" to mapOf(
            "value" to 42
        )
    )
)
 
// 安全的嵌套访问
val value = (nestedMap["level1"] as? Map<*, *>)
    ?.get("level2") as? Map<*, *>
    ?.get("value") as? Int
    ?: 0