集合函数式操作

// map 函数签名
// inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
 
fun main() {
    // 基础示例：将数字列表中的每个元素翻倍
    val numbers = listOf(1, 2, 3, 4, 5)          // 原始列表
    val doubled = numbers.map { it * 2 }         // 对每个元素执行 *2 操作
    println(doubled)                              // 输出: [2, 4, 6, 8, 10]
    
    // 类型转换：将整数转换为字符串
    val strings = numbers.map { "Number: $it" }  // Int -> String 的类型转换
    println(strings)                              // 输出: [Number: 1, Number: 2, ...]
    
    // 对象属性提取：从数据类中提取特定字段
    data class User(val name: String, val age: Int)  // 定义用户数据类
    
    val users = listOf(
        User("Alice", 25),                        // 创建用户列表
        User("Bob", 30),
        User("Charlie", 35)
    )
    
    val names = users.map { it.name }             // 提取所有用户的姓名
    println(names)                                 // 输出: [Alice, Bob, Charlie]
    
    val ages = users.map { it.age }               // 提取所有用户的年龄
    println(ages)                                  // 输出: [25, 30, 35]
}

// mapNotNull 函数签名
// inline fun <T, R : Any> Iterable<T>.mapNotNull(transform: (T) -> R?): List<R>
 
fun main() {
    // 场景：将字符串解析为整数，无效字符串返回 null
    val inputs = listOf("1", "2", "abc", "4", "xyz", "6")
    
    // 使用 map + filterNotNull 的传统方式（两次遍历）
    val traditional = inputs
        .map { it.toIntOrNull() }                 // 转换，可能产生 null: [1, 2, null, 4, null, 6]
        .filterNotNull()                          // 过滤掉 null 值
    
    // 使用 mapNotNull 的简洁方式（一次遍历，性能更优）
    val efficient = inputs.mapNotNull { it.toIntOrNull() }
    
    println(efficient)                            // 输出: [1, 2, 4, 6]
    
    // 实际应用：从可能为空的嵌套结构中安全提取数据
    data class Order(val product: String?)        // 产品名可能为空
    
    val orders = listOf(
        Order("iPhone"),                          // 有效订单
        Order(null),                              // 无效订单（产品为空）
        Order("MacBook"),                         // 有效订单
        Order(null)                               // 无效订单
    )
    
    // 安全提取所有非空产品名
    val products = orders.mapNotNull { it.product }
    println(products)                             // 输出: [iPhone, MacBook]
}

// mapIndexed 函数签名
// inline fun <T, R> Iterable<T>.mapIndexed(transform: (index: Int, T) -> R): List<R>
 
fun main() {
    val letters = listOf("a", "b", "c", "d")
    
    // 生成带序号的列表项
    val numbered = letters.mapIndexed { index, letter ->
        "${index + 1}. $letter"                   // 索引从0开始，+1 变成自然序号
    }
    println(numbered)                             // 输出: [1. a, 2. b, 3. c, 4. d]
    
    // 根据索引位置进行不同处理
    val processed = letters.mapIndexed { index, letter ->
        if (index % 2 == 0) {                     // 偶数索引位置
            letter.uppercase()                    // 转大写
        } else {                                  // 奇数索引位置
            letter                                // 保持原样
        }
    }
    println(processed)                            // 输出: [A, b, C, d]
    
    // 结合索引计算权重值
    val scores = listOf(100, 90, 80, 70)
    val weighted = scores.mapIndexed { index, score ->
        score * (scores.size - index)             // 越靠前权重越高
    }
    println(weighted)                             // 输出: [400, 270, 160, 70]
}

// flatten 函数签名
// fun <T> Iterable<Iterable<T>>.flatten(): List<T>
 
fun main() {
    // 二维列表展平
    val nested = listOf(
        listOf(1, 2, 3),                          // 第一个子列表
        listOf(4, 5),                             // 第二个子列表
        listOf(6, 7, 8, 9)                        // 第三个子列表
    )
    
    val flat = nested.flatten()                   // 展平为一维
    println(flat)                                 // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    // 实际场景：合并多个数据源
    val localData = listOf("local1", "local2")    // 本地数据
    val remoteData = listOf("remote1", "remote2") // 远程数据
    val cacheData = listOf("cache1")              // 缓存数据
    
    val allData = listOf(localData, remoteData, cacheData).flatten()
    println(allData)                              // 输出: [local1, local2, remote1, remote2, cache1]
    
    // 处理空列表的情况
    val withEmpty = listOf(
        listOf(1, 2),
        emptyList(),                              // 空列表会被安全处理
        listOf(3, 4)
    )
    println(withEmpty.flatten())                  // 输出: [1, 2, 3, 4]
}

┌─────────────────────────────────────────────────────────────┐
│  flatten 操作可视化                                          │
│                                                             │
│  输入: List<List<Int>>                                      │
│  ┌─────────┐  ┌─────────┐  ┌─────────────┐                 │
│  │ [1,2,3] │  │  [4,5]  │  │  [6,7,8,9]  │                 │
│  └────┬────┘  └────┬────┘  └──────┬──────┘                 │
│       │            │              │                         │
│       └────────────┼──────────────┘                         │
│                    ▼                                        │
│  输出: List<Int>                                            │
│  ┌─────────────────────────────────────────┐               │
│  │  [1, 2, 3, 4, 5, 6, 7, 8, 9]            │               │
│  └─────────────────────────────────────────┘               │
└─────────────────────────────────────────────────────────────┘

// flatMap 函数签名
// inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>
 
fun main() {
    // 基础示例：每个数字生成多个结果
    val numbers = listOf(1, 2, 3)
    
    // 每个数字生成 [n, n*10, n*100] 三个值
    val expanded = numbers.flatMap { n ->
        listOf(n, n * 10, n * 100)                // 返回一个列表
    }
    println(expanded)                             // 输出: [1, 10, 100, 2, 20, 200, 3, 30, 300]
    
    // 等价于 map + flatten
    val equivalent = numbers
        .map { n -> listOf(n, n * 10, n * 100) }  // 先 map: [[1,10,100], [2,20,200], [3,30,300]]
        .flatten()                                 // 再 flatten: [1, 10, 100, 2, 20, 200, ...]
    
    // 实际场景：获取所有用户的所有订单
    data class Order(val id: String, val amount: Double)
    data class Customer(val name: String, val orders: List<Order>)
    
    val customers = listOf(
        Customer("Alice", listOf(
            Order("A001", 100.0),
            Order("A002", 200.0)
        )),
        Customer("Bob", listOf(
            Order("B001", 150.0)
        )),
        Customer("Charlie", listOf())             // Charlie 没有订单
    )
    
    // 获取所有订单（展平嵌套结构）
    val allOrders = customers.flatMap { it.orders }
    println(allOrders.map { it.id })              // 输出: [A001, A002, B001]
    
    // 计算总金额
    val totalAmount = allOrders.sumOf { it.amount }
    println("Total: $totalAmount")                // 输出: Total: 450.0
}

// filter 函数签名
// inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // 筛选偶数
    val evens = numbers.filter { it % 2 == 0 }    // 谓词：是否为偶数
    println(evens)                                 // 输出: [2, 4, 6, 8, 10]
    
    // 筛选大于 5 的数
    val greaterThan5 = numbers.filter { it > 5 }
    println(greaterThan5)                          // 输出: [6, 7, 8, 9, 10]
    
    // 组合条件：偶数且大于 5
    val combined = numbers.filter { it % 2 == 0 && it > 5 }
    println(combined)                              // 输出: [6, 8, 10]
    
    // 对象过滤
    data class Product(
        val name: String,
        val price: Double,
        val inStock: Boolean
    )
    
    val products = listOf(
        Product("iPhone", 999.0, true),
        Product("MacBook", 1999.0, false),         // 缺货
        Product("AirPods", 199.0, true),
        Product("iPad", 799.0, true)
    )
    
    // 筛选有库存且价格低于 1000 的产品
    val affordable = products.filter { 
        it.inStock && it.price < 1000             // 复合条件
    }
    println(affordable.map { it.name })           // 输出: [iPhone, AirPods, iPad]
}

// filterNot 函数签名
// inline fun <T> Iterable<T>.filterNot(predicate: (T) -> Boolean): List<T>
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // 排除偶数（等价于筛选奇数）
    val odds = numbers.filterNot { it % 2 == 0 }
    println(odds)                                  // 输出: [1, 3, 5, 7, 9]
    
    // 实际场景：排除黑名单用户
    data class User(val id: Int, val name: String)
    
    val allUsers = listOf(
        User(1, "Alice"),
        User(2, "Bob"),
        User(3, "Charlie"),
        User(4, "David")
    )
    
    val blacklist = setOf(2, 4)                   // 黑名单用户 ID
    
    // 使用 filterNot 排除黑名单用户
    val activeUsers = allUsers.filterNot { it.id in blacklist }
    println(activeUsers.map { it.name })          // 输出: [Alice, Charlie]
    
    // 对比：使用 filter 实现相同效果（可读性稍差）
    val sameResult = allUsers.filter { it.id !in blacklist }
}

// filterIsInstance 函数签名（泛型版本）
// inline fun <reified R> Iterable<*>.filterIsInstance(): List<R>
 
fun main() {
    // 混合类型列表
    val mixed: List<Any> = listOf(
        1,                                         // Int
        "hello",                                   // String
        2.5,                                       // Double
        "world",                                   // String
        3,                                         // Int
        true,                                      // Boolean
        "kotlin"                                   // String
    )
    
    // 筛选所有字符串
    val strings: List<String> = mixed.filterIsInstance<String>()
    println(strings)                               // 输出: [hello, world, kotlin]
    
    // 筛选所有整数
    val ints: List<Int> = mixed.filterIsInstance<Int>()
    println(ints)                                  // 输出: [1, 3]
    
    // 筛选所有数字（Number 是 Int、Double 等的父类）
    val numbers: List<Number> = mixed.filterIsInstance<Number>()
    println(numbers)                               // 输出: [1, 2.5, 3]
    
    // 实际场景：处理多态事件流
    sealed class Event {                          // 密封类定义事件类型
        data class Click(val x: Int, val y: Int) : Event()
        data class Scroll(val delta: Int) : Event()
        data class KeyPress(val key: Char) : Event()
    }
    
    val events: List<Event> = listOf(
        Event.Click(100, 200),
        Event.Scroll(-50),
        Event.Click(150, 300),
        Event.KeyPress('A'),
        Event.Scroll(100)
    )
    
    // 只处理点击事件
    val clicks = events.filterIsInstance<Event.Click>()
    clicks.forEach { println("Clicked at (${it.x}, ${it.y})") }
    // 输出:
    // Clicked at (100, 200)
    // Clicked at (150, 300)
}

// filterNotNull 函数签名
// fun <T : Any> Iterable<T?>.filterNotNull(): List<T>
 
fun main() {
    // 包含 null 的列表
    val withNulls: List<String?> = listOf("a", null, "b", null, "c", null)
    
    // 过滤掉所有 null 值
    val withoutNulls: List<String> = withNulls.filterNotNull()
    println(withoutNulls)                          // 输出: [a, b, c]
    
    // 注意类型变化：List<String?> -> List<String>
    // 过滤后可以安全地调用非空方法
    withoutNulls.forEach { 
        println(it.length)                         // 无需 ?. 安全调用
    }
    
    // 实际场景：处理可能失败的批量操作
    fun fetchUserById(id: Int): String? {         // 模拟可能失败的查询
        return if (id % 2 == 0) "User$id" else null
    }
    
    val userIds = listOf(1, 2, 3, 4, 5, 6)
    
    // 批量查询，过滤失败结果
    val validUsers = userIds
        .map { fetchUserById(it) }                 // [null, User2, null, User4, null, User6]
        .filterNotNull()                           // [User2, User4, User6]
    
    println(validUsers)                            // 输出: [User2, User4, User6]
    
    // 更简洁的写法：使用 mapNotNull
    val sameResult = userIds.mapNotNull { fetchUserById(it) }
}

fun main() {
    data class Employee(
        val name: String,
        val department: String?,                   // 部门可能为空（新员工）
        val salary: Double,
        val isActive: Boolean
    )
    
    val employees = listOf(
        Employee("Alice", "Engineering", 80000.0, true),
        Employee("Bob", null, 50000.0, true),      // 新员工，未分配部门
        Employee("Charlie", "Sales", 60000.0, false), // 已离职
        Employee("David", "Engineering", 90000.0, true),
        Employee("Eve", null, 45000.0, false)      // 已离职的新员工
    )
    
    // 链式过滤：在职的、有部门的、工资超过 70000 的员工
    val seniorEngineers = employees
        .filter { it.isActive }                    // 第一步：筛选在职员工
        .filter { it.department != null }          // 第二步：筛选有部门的
        .filter { it.salary > 70000 }              // 第三步：筛选高薪员工
    
    println(seniorEngineers.map { it.name })       // 输出: [Alice, David]
    
    // 等价的单次过滤（性能更优，只遍历一次）
    val sameResult = employees.filter {
        it.isActive && it.department != null && it.salary > 70000
    }
}

fun main() {
    val largeList = (1..1_000_000).toList()
    
    // ❌ 低效：多次链式 filter 会创建多个中间列表
    val inefficient = largeList
        .filter { it % 2 == 0 }                    // 创建中间列表 1
        .filter { it % 3 == 0 }                    // 创建中间列表 2
        .filter { it > 500000 }                    // 创建中间列表 3
    
    // ✅ 高效方案 1：合并条件到单个 filter
    val efficient1 = largeList.filter {
        it % 2 == 0 && it % 3 == 0 && it > 500000  // 单次遍历，单个结果列表
    }
    
    // ✅ 高效方案 2：使用 Sequence（惰性求值，后续章节详解）
    val efficient2 = largeList.asSequence()        // 转换为序列
        .filter { it % 2 == 0 }                    // 惰性操作，不创建中间列表
        .filter { it % 3 == 0 }                    // 惰性操作
        .filter { it > 500000 }                    // 惰性操作
        .toList()                                   // 终端操作，触发计算
}

val data = listOf(1, 2, 3, 4, 5)
val result = data
    .map { it * 2 }
    .filter { it > 5 }
    .map { it - 1 }
println(result)

val lists = listOf(listOf(1, 2), listOf(3, 4))
val a = lists.flatMap { it.map { n -> n * 2 } }
val b = lists.map { it.map { n -> n * 2 } }.flatten()

// any 函数签名
// inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean
// fun <T> Iterable<T>.any(): Boolean  // 无参版本：检查集合是否非空
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // 检查是否存在偶数
    val hasEven = numbers.any { it % 2 == 0 }     // 找到 2 就返回 true
    println("Has even: $hasEven")                  // 输出: Has even: true
    
    // 检查是否存在大于 100 的数
    val hasLarge = numbers.any { it > 100 }       // 遍历完所有元素都不满足
    println("Has large: $hasLarge")                // 输出: Has large: false
    
    // 无参版本：检查集合是否非空
    val emptyList = emptyList<Int>()
    val nonEmptyList = listOf(1, 2, 3)
    
    println(emptyList.any())                       // 输出: false（空集合）
    println(nonEmptyList.any())                    // 输出: true（非空集合）
    
    // 实际场景：验证用户输入
    data class FormField(val name: String, val value: String, val isRequired: Boolean)
    
    val formFields = listOf(
        FormField("username", "john", true),
        FormField("email", "", true),              // 必填但为空
        FormField("phone", "", false)              // 非必填，可为空
    )
    
    // 检查是否有必填字段为空
    val hasEmptyRequired = formFields.any { 
        it.isRequired && it.value.isEmpty()        // 必填且值为空
    }
    
    if (hasEmptyRequired) {
        println("Error: Some required fields are empty!")
    }
}

// all 函数签名
// inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean
 
fun main() {
    val numbers = listOf(2, 4, 6, 8, 10)
    
    // 检查是否全部为偶数
    val allEven = numbers.all { it % 2 == 0 }
    println("All even: $allEven")                  // 输出: All even: true
    
    // 检查是否全部为正数
    val mixedNumbers = listOf(1, -2, 3, -4, 5)
    val allPositive = mixedNumbers.all { it > 0 } // 遇到 -2 就返回 false
    println("All positive: $allPositive")          // 输出: All positive: false
    
    // 重要特性：空集合对 all 返回 true（vacuous truth，空真）
    val emptyList = emptyList<Int>()
    println(emptyList.all { it > 0 })              // 输出: true（空集合）
    
    // 实际场景：验证所有订单是否已支付
    data class Order(val id: String, val isPaid: Boolean, val amount: Double)
    
    val orders = listOf(
        Order("001", true, 100.0),
        Order("002", true, 200.0),
        Order("003", true, 150.0)
    )
    
    val allPaid = orders.all { it.isPaid }
    println("All orders paid: $allPaid")           // 输出: All orders paid: true
    
    // 组合条件：所有订单已支付且金额大于 0
    val allValid = orders.all { it.isPaid && it.amount > 0 }
    println("All orders valid: $allValid")         // 输出: All orders valid: true
}

// none 函数签名
// inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean
// fun <T> Iterable<T>.none(): Boolean  // 无参版本：检查集合是否为空
 
fun main() {
    val numbers = listOf(1, 3, 5, 7, 9)            // 全是奇数
    
    // 检查是否没有偶数
    val noEven = numbers.none { it % 2 == 0 }
    println("No even numbers: $noEven")            // 输出: No even numbers: true
    
    // 检查是否没有负数
    val noNegative = numbers.none { it < 0 }
    println("No negative: $noNegative")            // 输出: No negative: true
    
    // 无参版本：检查集合是否为空
    val emptyList = emptyList<Int>()
    println(emptyList.none())                      // 输出: true（空集合）
    println(numbers.none())                        // 输出: false（非空集合）
    
    // 实际场景：检查是否没有错误
    data class ValidationResult(val field: String, val hasError: Boolean, val message: String)
    
    val results = listOf(
        ValidationResult("username", false, ""),
        ValidationResult("email", false, ""),
        ValidationResult("password", false, "")
    )
    
    // 检查是否没有任何验证错误
    val noErrors = results.none { it.hasError }
    if (noErrors) {
        println("Validation passed!")              // 输出: Validation passed!
    }
}

// contains 函数签名
// operator fun <T> Iterable<T>.contains(element: T): Boolean
 
fun main() {
    val fruits = listOf("apple", "banana", "cherry", "date")
    
    // 使用 contains 方法
    val hasApple = fruits.contains("apple")
    println("Has apple: $hasApple")                // 输出: Has apple: true
    
    // 使用 in 操作符（推荐，更简洁）
    val hasMango = "mango" in fruits
    println("Has mango: $hasMango")                // 输出: Has mango: false
    
    // 使用 !in 检查不包含
    val noGrape = "grape" !in fruits
    println("No grape: $noGrape")                  // 输出: No grape: true
    
    // 数字集合
    val numbers = listOf(1, 2, 3, 4, 5)
    println(3 in numbers)                          // 输出: true
    println(10 in numbers)                         // 输出: false
    
    // 实际场景：权限检查
    val userPermissions = setOf("read", "write", "delete")
    val requiredPermission = "admin"
    
    if (requiredPermission in userPermissions) {
        println("Access granted")
    } else {
        println("Access denied")                   // 输出: Access denied
    }
    
    // containsAll：检查是否包含所有指定元素
    val requiredPermissions = listOf("read", "write")
    val hasAllRequired = userPermissions.containsAll(requiredPermissions)
    println("Has all required: $hasAllRequired")   // 输出: Has all required: true
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val predicate: (Int) -> Boolean = { it > 3 }
    
    // 逻辑等价关系演示
    println("=== 逻辑等价关系 ===")
    
    // any 与 none 的关系：互为否定
    println(numbers.any(predicate))                // true（存在 4, 5 > 3）
    println(!numbers.none(predicate))              // true（等价）
    
    // none 与 any 的关系：互为否定
    println(numbers.none(predicate))               // false
    println(!numbers.any(predicate))               // false（等价）
    
    // all 与 any + 否定谓词的关系
    val allGreaterThan0 = numbers.all { it > 0 }
    val noneNotGreaterThan0 = numbers.none { it <= 0 }  // 否定谓词
    println(allGreaterThan0)                       // true
    println(noneNotGreaterThan0)                   // true（等价）
}

┌─────────────────────────────────────────────────────────────────┐
│  any / all / none 逻辑关系图                                     │
│                                                                 │
│  ┌─────────────────┐         ┌─────────────────┐               │
│  │   any { P }     │ ══════► │  !none { P }    │               │
│  │  "存在满足P的"   │  等价    │  "并非全不满足P" │               │
│  └─────────────────┘         └─────────────────┘               │
│                                                                 │
│  ┌─────────────────┐         ┌─────────────────┐               │
│  │   all { P }     │ ══════► │  none { !P }    │               │
│  │  "全部满足P"     │  等价    │  "没有不满足P的" │               │
│  └─────────────────┘         └─────────────────┘               │
│                                                                 │
│  ┌─────────────────┐         ┌─────────────────┐               │
│  │   none { P }    │ ══════► │  !any { P }     │               │
│  │  "没有满足P的"   │  等价    │  "并非存在满足P" │               │
│  └─────────────────┘         └─────────────────┘               │
└─────────────────────────────────────────────────────────────────┘

// find 函数签名
// inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?
// inline fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // find：查找第一个偶数
    val firstEven = numbers.find { it % 2 == 0 }
    println("First even: $firstEven")              // 输出: First even: 2
    
    // findLast：查找最后一个偶数
    val lastEven = numbers.findLast { it % 2 == 0 }
    println("Last even: $lastEven")                // 输出: Last even: 10
    
    // 查找不存在的元素
    val notFound = numbers.find { it > 100 }
    println("Not found: $notFound")                // 输出: Not found: null
    
    // 实际场景：查找用户
    data class User(val id: Int, val name: String, val role: String)
    
    val users = listOf(
        User(1, "Alice", "admin"),
        User(2, "Bob", "user"),
        User(3, "Charlie", "admin"),
        User(4, "David", "user")
    )
    
    // 查找第一个管理员
    val firstAdmin = users.find { it.role == "admin" }
    println("First admin: ${firstAdmin?.name}")    // 输出: First admin: Alice
    
    // 查找最后一个管理员
    val lastAdmin = users.findLast { it.role == "admin" }
    println("Last admin: ${lastAdmin?.name}")      // 输出: Last admin: Charlie
    
    // 安全处理：使用 let 或 Elvis 操作符
    users.find { it.name == "Eve" }?.let { user ->
        println("Found: ${user.name}")
    } ?: println("User not found")                 // 输出: User not found
}

// first 函数签名
// fun <T> Iterable<T>.first(): T
// inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T
 
// firstOrNull 函数签名
// fun <T> Iterable<T>.firstOrNull(): T?
// inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T?
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val emptyList = emptyList<Int>()
    
    // 获取第一个元素
    println(numbers.first())                       // 输出: 1
    println(numbers.firstOrNull())                 // 输出: 1
    
    // 空集合的处理差异
    // println(emptyList.first())                  // ❌ 抛出 NoSuchElementException
    println(emptyList.firstOrNull())               // 输出: null（安全）
    
    // 带条件的查找
    val firstEven = numbers.first { it % 2 == 0 }
    println("First even: $firstEven")              // 输出: First even: 2
    
    // 条件不满足时的处理差异
    // val notFound = numbers.first { it > 100 }  // ❌ 抛出 NoSuchElementException
    val notFoundSafe = numbers.firstOrNull { it > 100 }
    println("Not found: $notFoundSafe")            // 输出: Not found: null
    
    // 实际场景：获取默认值
    val defaultValue = numbers.firstOrNull { it > 100 } ?: -1
    println("With default: $defaultValue")         // 输出: With default: -1
}

// last 函数签名
// fun <T> List<T>.last(): T
// inline fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T
 
// lastOrNull 函数签名
// fun <T> List<T>.lastOrNull(): T?
// inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    
    // 获取最后一个元素
    println(numbers.last())                        // 输出: 5
    println(numbers.lastOrNull())                  // 输出: 5
    
    // 带条件的查找
    val lastEven = numbers.last { it % 2 == 0 }
    println("Last even: $lastEven")                // 输出: Last even: 4
    
    val lastOdd = numbers.lastOrNull { it % 2 != 0 }
    println("Last odd: $lastOdd")                  // 输出: Last odd: 5
    
    // 实际场景：获取最新记录
    data class LogEntry(val timestamp: Long, val message: String, val level: String)
    
    val logs = listOf(
        LogEntry(1000, "App started", "INFO"),
        LogEntry(2000, "User logged in", "INFO"),
        LogEntry(3000, "Database error", "ERROR"),
        LogEntry(4000, "Retry successful", "INFO"),
        LogEntry(5000, "App closed", "INFO")
    )
    
    // 获取最后一条错误日志
    val lastError = logs.lastOrNull { it.level == "ERROR" }
    println("Last error: ${lastError?.message}")   // 输出: Last error: Database error
    
    // 获取最新日志
    val latestLog = logs.lastOrNull()
    println("Latest: ${latestLog?.message}")       // 输出: Latest: App closed
}

// single 函数签名
// fun <T> Iterable<T>.single(): T
// inline fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T
 
// singleOrNull 函数签名
// fun <T> Iterable<T>.singleOrNull(): T?
// inline fun <T> Iterable<T>.singleOrNull(predicate: (T) -> Boolean): T?
 
fun main() {
    // 单元素集合
    val singleElement = listOf(42)
    println(singleElement.single())                // 输出: 42
    
    // 多元素集合
    val multipleElements = listOf(1, 2, 3)
    // println(multipleElements.single())          // ❌ 抛出 IllegalArgumentException
    println(multipleElements.singleOrNull())       // 输出: null（多于一个元素）
    
    // 空集合
    val emptyList = emptyList<Int>()
    // println(emptyList.single())                 // ❌ 抛出 NoSuchElementException
    println(emptyList.singleOrNull())              // 输出: null（没有元素）
    
    // 带条件的查找
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    
    // 查找唯一满足条件的元素
    val singleGreaterThan5 = numbers.singleOrNull { it > 5 }
    println("Single > 5: $singleGreaterThan5")     // 输出: Single > 5: 6（只有一个）
    
    val singleGreaterThan3 = numbers.singleOrNull { it > 3 }
    println("Single > 3: $singleGreaterThan3")     // 输出: Single > 3: null（有多个：4,5,6）
    
    val singleGreaterThan10 = numbers.singleOrNull { it > 10 }
    println("Single > 10: $singleGreaterThan10")   // 输出: Single > 10: null（没有）
    
    // 实际场景：根据唯一标识查找
    data class Config(val key: String, val value: String)
    
    val configs = listOf(
        Config("database.url", "jdbc:mysql://localhost"),
        Config("database.user", "root"),
        Config("database.password", "secret")
    )
    
    // 查找唯一的配置项
    val dbUrl = configs.singleOrNull { it.key == "database.url" }
    println("DB URL: ${dbUrl?.value}")             // 输出: DB URL: jdbc:mysql://localhost
    
    // 如果配置重复，返回 null（数据异常）
    val duplicateConfigs = configs + Config("database.url", "jdbc:postgresql://localhost")
    val ambiguousUrl = duplicateConfigs.singleOrNull { it.key == "database.url" }
    println("Ambiguous: $ambiguousUrl")            // 输出: Ambiguous: null（有重复）
}

val numbers = listOf(1, 2, 3, 4, 5)
val result = numbers.all { it > 0 } && numbers.none { it > 10 }
println(result)

val items = listOf("a", "bb", "ccc", "dd", "e")
val result = items.singleOrNull { it.length == 2 }

// count 函数签名
// fun <T> Iterable<T>.count(): Int
// inline fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // 无参版本：统计总数
    val total = numbers.count()
    println("Total count: $total")                 // 输出: Total count: 10
    
    // 带谓词版本：统计满足条件的元素数量
    val evenCount = numbers.count { it % 2 == 0 } // 统计偶数个数
    println("Even count: $evenCount")              // 输出: Even count: 5
    
    // 统计大于 5 的元素数量
    val greaterThan5 = numbers.count { it > 5 }
    println("Greater than 5: $greaterThan5")       // 输出: Greater than 5: 5
    
    // 实际场景：统计订单状态
    data class Order(val id: String, val status: String, val amount: Double)
    
    val orders = listOf(
        Order("001", "completed", 100.0),
        Order("002", "pending", 200.0),
        Order("003", "completed", 150.0),
        Order("004", "cancelled", 80.0),
        Order("005", "pending", 300.0)
    )
    
    // 统计各状态订单数量
    val completedCount = orders.count { it.status == "completed" }
    val pendingCount = orders.count { it.status == "pending" }
    val cancelledCount = orders.count { it.status == "cancelled" }
    
    println("Completed: $completedCount")          // 输出: Completed: 2
    println("Pending: $pendingCount")              // 输出: Pending: 2
    println("Cancelled: $cancelledCount")          // 输出: Cancelled: 1
    
    // 注意：对于 List，使用 size 属性比 count() 更高效
    // size 是 O(1)，count() 需要遍历是 O(n)
    println(numbers.size)                          // 推荐：直接访问属性
    println(numbers.count())                       // 不推荐：需要遍历
}

// sum 函数签名（仅适用于数值类型集合）
// fun Iterable<Int>.sum(): Int
// fun Iterable<Long>.sum(): Long
// fun Iterable<Double>.sum(): Double
 
// sumOf 函数签名（通用版本）
// inline fun <T> Iterable<T>.sumOf(selector: (T) -> Int): Int
// inline fun <T> Iterable<T>.sumOf(selector: (T) -> Double): Double
 
fun main() {
    // 数值集合直接求和
    val integers = listOf(1, 2, 3, 4, 5)
    val intSum = integers.sum()
    println("Int sum: $intSum")                    // 输出: Int sum: 15
    
    val doubles = listOf(1.5, 2.5, 3.0, 4.0)
    val doubleSum = doubles.sum()
    println("Double sum: $doubleSum")              // 输出: Double sum: 11.0
    
    // 使用 sumOf 从对象中提取数值求和
    data class Product(val name: String, val price: Double, val quantity: Int)
    
    val cart = listOf(
        Product("iPhone", 999.0, 1),
        Product("AirPods", 199.0, 2),
        Product("Case", 29.0, 3)
    )
    
    // 计算总价格（单价 × 数量）
    val totalPrice = cart.sumOf { it.price * it.quantity }
    println("Total price: $totalPrice")            // 输出: Total price: 1484.0
    
    // 计算总数量
    val totalQuantity = cart.sumOf { it.quantity }
    println("Total quantity: $totalQuantity")      // 输出: Total quantity: 6
    
    // sumOf 支持不同的返回类型
    val sumAsInt = cart.sumOf { it.quantity }      // 返回 Int
    val sumAsDouble = cart.sumOf { it.price }      // 返回 Double
    val sumAsLong = cart.sumOf { it.quantity.toLong() }  // 返回 Long
    
    // 条件求和：只计算特定商品
    val expensiveTotal = cart
        .filter { it.price > 100 }                 // 先过滤
        .sumOf { it.price * it.quantity }          // 再求和
    println("Expensive items total: $expensiveTotal")  // 输出: 1397.0
}

// average 函数签名
// fun Iterable<Int>.average(): Double
// fun Iterable<Double>.average(): Double
 
fun main() {
    val scores = listOf(85, 90, 78, 92, 88)
    
    // 计算平均分
    val avgScore = scores.average()
    println("Average score: $avgScore")            // 输出: Average score: 86.6
    
    // 空集合返回 NaN
    val emptyList = emptyList<Int>()
    val emptyAvg = emptyList.average()
    println("Empty average: $emptyAvg")            // 输出: Empty average: NaN
    println("Is NaN: ${emptyAvg.isNaN()}")         // 输出: Is NaN: true
    
    // 处理 NaN 的安全方式
    val safeAvg = if (emptyList.isEmpty()) 0.0 else emptyList.average()
    println("Safe average: $safeAvg")              // 输出: Safe average: 0.0
    
    // 实际场景：计算商品平均评分
    data class Review(val productId: String, val rating: Int, val comment: String)
    
    val reviews = listOf(
        Review("P001", 5, "Excellent!"),
        Review("P001", 4, "Good"),
        Review("P001", 5, "Love it"),
        Review("P001", 3, "OK"),
        Review("P001", 4, "Nice")
    )
    
    // 计算平均评分
    val avgRating = reviews.map { it.rating }.average()
    println("Average rating: %.1f".format(avgRating))  // 输出: Average rating: 4.2
    
    // 或使用 sumOf 手动计算（更灵活）
    val manualAvg = reviews.sumOf { it.rating }.toDouble() / reviews.size
    println("Manual average: %.1f".format(manualAvg))  // 输出: Manual average: 4.2
}

// maxOrNull / minOrNull 函数签名
// fun <T : Comparable<T>> Iterable<T>.maxOrNull(): T?
// fun <T : Comparable<T>> Iterable<T>.minOrNull(): T?
 
// maxByOrNull / minByOrNull 函数签名
// inline fun <T, R : Comparable<R>> Iterable<T>.maxByOrNull(selector: (T) -> R): T?
// inline fun <T, R : Comparable<R>> Iterable<T>.minByOrNull(selector: (T) -> R): T?
 
fun main() {
    val numbers = listOf(3, 1, 4, 1, 5, 9, 2, 6)
    
    // 基础用法：获取最大/最小值
    val max = numbers.maxOrNull()
    val min = numbers.minOrNull()
    println("Max: $max, Min: $min")                // 输出: Max: 9, Min: 1
    
    // 空集合返回 null
    val emptyList = emptyList<Int>()
    println("Empty max: ${emptyList.maxOrNull()}") // 输出: Empty max: null
    
    // 使用 Elvis 操作符提供默认值
    val safeMax = emptyList.maxOrNull() ?: 0
    println("Safe max: $safeMax")                  // 输出: Safe max: 0
    
    // 字符串集合的最大/最小（按字典序）
    val words = listOf("apple", "banana", "cherry")
    println("Max word: ${words.maxOrNull()}")      // 输出: Max word: cherry
    println("Min word: ${words.minOrNull()}")      // 输出: Min word: apple
    
    // maxByOrNull / minByOrNull：根据选择器比较
    data class Employee(val name: String, val salary: Double, val age: Int)
    
    val employees = listOf(
        Employee("Alice", 80000.0, 30),
        Employee("Bob", 95000.0, 45),
        Employee("Charlie", 70000.0, 25),
        Employee("David", 85000.0, 35)
    )
    
    // 找出薪资最高的员工
    val highestPaid = employees.maxByOrNull { it.salary }
    println("Highest paid: ${highestPaid?.name}")  // 输出: Highest paid: Bob
    
    // 找出年龄最小的员工
    val youngest = employees.minByOrNull { it.age }
    println("Youngest: ${youngest?.name}")         // 输出: Youngest: Charlie
    
    // maxOfOrNull / minOfOrNull：直接返回选择器的值（而非元素本身）
    val maxSalary = employees.maxOfOrNull { it.salary }
    val minAge = employees.minOfOrNull { it.age }
    println("Max salary: $maxSalary")              // 输出: Max salary: 95000.0
    println("Min age: $minAge")                    // 输出: Min age: 25
}

fun main() {
    data class Transaction(
        val id: String,
        val type: String,           // "income" 或 "expense"
        val amount: Double,
        val category: String
    )
    
    val transactions = listOf(
        Transaction("T001", "income", 5000.0, "salary"),
        Transaction("T002", "expense", 1200.0, "rent"),
        Transaction("T003", "expense", 300.0, "food"),
        Transaction("T004", "income", 500.0, "bonus"),
        Transaction("T005", "expense", 150.0, "transport"),
        Transaction("T006", "expense", 200.0, "food"),
        Transaction("T007", "income", 100.0, "interest")
    )
    
    // 综合统计
    val totalIncome = transactions
        .filter { it.type == "income" }            // 筛选收入
        .sumOf { it.amount }                       // 求和
    
    val totalExpense = transactions
        .filter { it.type == "expense" }           // 筛选支出
        .sumOf { it.amount }                       // 求和
    
    val balance = totalIncome - totalExpense
    
    println("=== 财务报表 ===")
    println("Total Income: $$totalIncome")         // 输出: Total Income: $5600.0
    println("Total Expense: $$totalExpense")       // 输出: Total Expense: $1850.0
    println("Balance: $$balance")                  // 输出: Balance: $3750.0
    
    // 统计各类别支出
    val foodExpense = transactions
        .filter { it.type == "expense" && it.category == "food" }
        .sumOf { it.amount }
    println("Food expense: $$foodExpense")         // 输出: Food expense: $500.0
    
    // 计算平均单笔支出
    val avgExpense = transactions
        .filter { it.type == "expense" }
        .map { it.amount }
        .average()
    println("Avg expense: $%.2f".format(avgExpense))  // 输出: Avg expense: $462.50
    
    // 找出最大单笔支出
    val maxExpense = transactions
        .filter { it.type == "expense" }
        .maxByOrNull { it.amount }
    println("Max expense: ${maxExpense?.category} - $${maxExpense?.amount}")
    // 输出: Max expense: rent - $1200.0
}

// groupBy 函数签名
// inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>
// inline fun <T, K, V> Iterable<T>.groupBy(
//     keySelector: (T) -> K,
//     valueTransform: (T) -> V
// ): Map<K, List<V>>
 
fun main() {
    // 基础示例：按奇偶分组
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    val byParity = numbers.groupBy { 
        if (it % 2 == 0) "even" else "odd"         // 键选择器
    }
    println(byParity)
    // 输出: {odd=[1, 3, 5, 7, 9], even=[2, 4, 6, 8, 10]}
    
    // 按首字母分组
    val words = listOf("apple", "apricot", "banana", "blueberry", "cherry")
    
    val byFirstLetter = words.groupBy { it.first() }
    println(byFirstLetter)
    // 输出: {a=[apple, apricot], b=[banana, blueberry], c=[cherry]}
    
    // 实际场景：员工按部门分组
    data class Employee(val name: String, val department: String, val salary: Double)
    
    val employees = listOf(
        Employee("Alice", "Engineering", 80000.0),
        Employee("Bob", "Engineering", 90000.0),
        Employee("Charlie", "Sales", 70000.0),
        Employee("David", "Sales", 75000.0),
        Employee("Eve", "HR", 65000.0)
    )
    
    // 按部门分组
    val byDepartment = employees.groupBy { it.department }
    
    byDepartment.forEach { (dept, emps) ->
        println("$dept: ${emps.map { it.name }}")
    }
    // 输出:
    // Engineering: [Alice, Bob]
    // Sales: [Charlie, David]
    // HR: [Eve]
    
    // 带值转换的 groupBy：只保留员工姓名
    val namesByDept = employees.groupBy(
        keySelector = { it.department },           // 键：部门
        valueTransform = { it.name }               // 值：只取姓名
    )
    println(namesByDept)
    // 输出: {Engineering=[Alice, Bob], Sales=[Charlie, David], HR=[Eve]}
}

fun main() {
    data class Student(
        val name: String,
        val grade: Int,           // 年级：1-12
        val score: Double,
        val gender: String
    )
    
    val students = listOf(
        Student("Alice", 10, 95.0, "F"),
        Student("Bob", 10, 88.0, "M"),
        Student("Charlie", 11, 92.0, "M"),
        Student("Diana", 11, 96.0, "F"),
        Student("Eve", 10, 91.0, "F"),
        Student("Frank", 12, 85.0, "M")
    )
    
    // 按年级分组后进行聚合计算
    val avgScoreByGrade = students
        .groupBy { it.grade }                      // 先分组
        .mapValues { (_, students) ->              // 对每组计算平均分
            students.map { it.score }.average()
        }
    
    println("Average score by grade:")
    avgScoreByGrade.forEach { (grade, avg) ->
        println("  Grade $grade: %.1f".format(avg))
    }
    // 输出:
    // Average score by grade:
    //   Grade 10: 91.3
    //   Grade 11: 94.0
    //   Grade 12: 85.0
    
    // 多级分组：先按年级，再按性别
    val byGradeAndGender = students
        .groupBy { it.grade }                      // 第一级：按年级
        .mapValues { (_, gradeStudents) ->
            gradeStudents.groupBy { it.gender }    // 第二级：按性别
        }
    
    println("\nStudents by grade and gender:")
    byGradeAndGender.forEach { (grade, byGender) ->
        println("Grade $grade:")
        byGender.forEach { (gender, list) ->
            println("  $gender: ${list.map { it.name }}")
        }
    }
    // 输出:
    // Grade 10:
    //   F: [Alice, Eve]
    //   M: [Bob]
    // Grade 11:
    //   M: [Charlie]
    //   F: [Diana]
    // Grade 12:
    //   M: [Frank]
    
    // 统计每组数量
    val countByGrade = students
        .groupBy { it.grade }
        .mapValues { it.value.size }               // 转换为数量
    
    println("\nCount by grade: $countByGrade")
    // 输出: Count by grade: {10=3, 11=2, 12=1}
}

// groupingBy 函数签名
// inline fun <T, K> Iterable<T>.groupingBy(
//     crossinline keySelector: (T) -> K
// ): Grouping<T, K>
 
// Grouping 提供的聚合方法
// fun <T, K> Grouping<T, K>.eachCount(): Map<K, Int>
// fun <T, K, R> Grouping<T, K>.fold(...): Map<K, R>
// fun <T, K, R> Grouping<T, K>.reduce(...): Map<K, R>
// fun <T, K, R> Grouping<T, K>.aggregate(...): Map<K, R>
 
fun main() {
    val words = listOf("apple", "apricot", "banana", "blueberry", "cherry", "coconut")
    
    // eachCount()：统计每组元素数量
    val countByFirstLetter = words
        .groupingBy { it.first() }                 // 创建 Grouping
        .eachCount()                               // 统计每组数量
    
    println("Count by first letter: $countByFirstLetter")
    // 输出: Count by first letter: {a=2, b=2, c=2}
    
    // 对比 groupBy 实现相同功能
    val sameResult = words
        .groupBy { it.first() }                    // 创建完整的 Map<Char, List<String>>
        .mapValues { it.value.size }               // 再转换为数量
    
    // groupingBy + eachCount 更高效，因为不需要创建中间列表
    
    // fold()：对每组进行折叠操作
    data class Item(val category: String, val price: Double)
    
    val items = listOf(
        Item("food", 10.0),
        Item("food", 20.0),
        Item("electronics", 100.0),
        Item("food", 15.0),
        Item("electronics", 200.0)
    )
    
    // 计算每个类别的总价
    val totalByCategory = items
        .groupingBy { it.category }
        .fold(0.0) { accumulator, item ->          // 初始值 0.0
            accumulator + item.price               // 累加价格
        }
    
    println("Total by category: $totalByCategory")
    // 输出: Total by category: {food=45.0, electronics=300.0}
    
    // reduce()：类似 fold，但使用第一个元素作为初始值
    val maxPriceByCategory = items
        .groupingBy { it.category }
        .reduce { _, maxItem, item ->              // key 参数通常不用
            if (item.price > maxItem.price) item else maxItem
        }
    
    println("Max price item by category:")
    maxPriceByCategory.forEach { (category, item) ->
        println("  $category: ${item.price}")
    }
    // 输出:
    // Max price item by category:
    //   food: 20.0
    //   electronics: 200.0
}

// aggregate 函数签名
// inline fun <T, K, R> Grouping<T, K>.aggregate(
//     operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R
// ): Map<K, R>
 
fun main() {
    data class Sale(val product: String, val quantity: Int, val price: Double)
    
    val sales = listOf(
        Sale("iPhone", 2, 999.0),
        Sale("MacBook", 1, 1999.0),
        Sale("iPhone", 3, 999.0),
        Sale("AirPods", 5, 199.0),
        Sale("MacBook", 2, 1999.0),
        Sale("AirPods", 3, 199.0)
    )
    
    // 使用 aggregate 计算每个产品的销售统计
    data class SalesSummary(
        val totalQuantity: Int,
        val totalRevenue: Double,
        val transactionCount: Int
    )
    
    val salesSummary = sales
        .groupingBy { it.product }
        .aggregate { _, accumulator: SalesSummary?, sale, first ->
            if (first) {
                // 第一个元素：初始化累加器
                SalesSummary(
                    totalQuantity = sale.quantity,
                    totalRevenue = sale.quantity * sale.price,
                    transactionCount = 1
                )
            } else {
                // 后续元素：累加到现有值
                SalesSummary(
                    totalQuantity = accumulator!!.totalQuantity + sale.quantity,
                    totalRevenue = accumulator.totalRevenue + sale.quantity * sale.price,
                    transactionCount = accumulator.transactionCount + 1
                )
            }
        }
    
    println("=== Sales Summary ===")
    salesSummary.forEach { (product, summary) ->
        println("$product:")
        println("  Quantity: ${summary.totalQuantity}")
        println("  Revenue: $${summary.totalRevenue}")
        println("  Transactions: ${summary.transactionCount}")
    }
    // 输出:
    // === Sales Summary ===
    // iPhone:
    //   Quantity: 5
    //   Revenue: $4995.0
    //   Transactions: 2
    // MacBook:
    //   Quantity: 3
    //   Revenue: $5997.0
    //   Transactions: 2
    // AirPods:
    //   Quantity: 8
    //   Revenue: $1592.0
    //   Transactions: 2
}

val numbers = listOf(1, 2, 3, 4, 5)
val result = numbers.filter { it > 2 }.sumOf { it * 2 }
println(result)

// partition 函数签名
// inline fun <T> Iterable<T>.partition(
//     predicate: (T) -> Boolean
// ): Pair<List<T>, List<T>>
 
fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    // 按奇偶分区
    val (evens, odds) = numbers.partition { it % 2 == 0 }
    println("Evens: $evens")                       // 输出: Evens: [2, 4, 6, 8, 10]
    println("Odds: $odds")                         // 输出: Odds: [1, 3, 5, 7, 9]
    
    // 注意：使用解构声明 (destructuring declaration) 可以直接获取两个列表
    // val result = numbers.partition { it % 2 == 0 }
    // val evens = result.first
    // val odds = result.second
    
    // 按阈值分区
    val (large, small) = numbers.partition { it > 5 }
    println("Large (>5): $large")                  // 输出: Large (>5): [6, 7, 8, 9, 10]
    println("Small (<=5): $small")                 // 输出: Small (<=5): [1, 2, 3, 4, 5]
}

fun main() {
    // 场景1：验证结果分类
    data class ValidationResult(
        val field: String,
        val isValid: Boolean,
        val message: String
    )
    
    val results = listOf(
        ValidationResult("username", true, "OK"),
        ValidationResult("email", false, "Invalid format"),
        ValidationResult("password", true, "OK"),
        ValidationResult("phone", false, "Too short"),
        ValidationResult("age", true, "OK")
    )
    
    // 分离有效和无效的验证结果
    val (valid, invalid) = results.partition { it.isValid }
    
    println("Valid fields: ${valid.map { it.field }}")
    // 输出: Valid fields: [username, password, age]
    
    println("Invalid fields:")
    invalid.forEach { println("  ${it.field}: ${it.message}") }
    // 输出:
    // Invalid fields:
    //   email: Invalid format
    //   phone: Too short
    
    // 场景2：任务调度 - 分离已完成和待处理任务
    data class Task(val id: Int, val name: String, val isCompleted: Boolean)
    
    val tasks = listOf(
        Task(1, "Design UI", true),
        Task(2, "Implement API", false),
        Task(3, "Write tests", true),
        Task(4, "Deploy", false),
        Task(5, "Documentation", false)
    )
    
    val (completed, pending) = tasks.partition { it.isCompleted }
    
    println("\n=== Task Status ===")
    println("Completed (${completed.size}): ${completed.map { it.name }}")
    println("Pending (${pending.size}): ${pending.map { it.name }}")
    // 输出:
    // === Task Status ===
    // Completed (2): [Design UI, Write tests]
    // Pending (3): [Implement API, Deploy, Documentation]
    
    // 场景3：数据清洗 - 分离有效和无效数据
    val rawData = listOf("123", "abc", "456", "", "789", "xyz", null, "0")
    
    // 使用 filterNotNull 先去除 null，再分区
    val (validNumbers, invalidEntries) = rawData
        .filterNotNull()                           // 先过滤 null
        .partition { it.toIntOrNull() != null }    // 再按是否为有效数字分区
    
    println("\nValid numbers: $validNumbers")      // 输出: Valid numbers: [123, 456, 789, 0]
    println("Invalid entries: $invalidEntries")    // 输出: Invalid entries: [abc, , xyz]
}