Kotlin集合与泛型

一、集合类型

Kotlin提供了三种主要的集合类型：List、Set和Map。

1. List（列表）
   有序集合，允许重复元素。

fun main() {
    // 不可变List
    val numbers: List<Int> = listOf(1, 2, 3, 4, 5)
    println("不可变List: $numbers")
    
    // 可变List
    val mutableNumbers = mutableListOf(10, 20, 30)
    mutableNumbers.add(40)
    mutableNumbers.remove(20)
    println("可变List: $mutableNumbers")
    
    // 访问元素
    println("第一个元素: ${numbers[0]}")
    println("第三个元素: ${numbers.get(2)}")
}

2. Set（集合）
   无序集合，不允许重复元素。

fun main() {
    // 不可变Set
    val colors: Set<String> = setOf("Red", "Green", "Blue", "Red")
    println("不可变Set: $colors") // 输出不包含重复的Red
    
    // 可变Set
    val mutableColors = mutableSetOf("Apple", "Banana")
    mutableColors.add("Orange")
    mutableColors.remove("Banana")
    println("可变Set: $mutableColors")
}

3. Map（映射）
   键值对集合。

fun main() {
    // 不可变Map
    val capitalCities: Map<String, String> = mapOf(
        "China" to "Beijing",
        "Japan" to "Tokyo",
        "USA" to "Washington"
    )
    println("不可变Map: $capitalCities")
    println("中国的首都: ${capitalCities["China"]}")
    
    // 可变Map
    val mutableMap = mutableMapOf("A" to 1, "B" to 2)
    mutableMap["C"] = 3
    mutableMap.remove("B")
    println("可变Map: $mutableMap")
}

二、集合操作

1. 常用操作

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    
    // 过滤
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("偶数: $evenNumbers")
    
    // 映射
    val squaredNumbers = numbers.map { it * it }
    println("平方数: $squaredNumbers")
    
    // 查找
    val firstEven = numbers.first { it % 2 == 0 }
    println("第一个偶数: $firstEven")
    
    // 聚合
    val sum = numbers.sum()
    println("总和: $sum")
    
    // 分组
    val grouped = numbers.groupBy { if (it % 2 == 0) "Even" else "Odd" }
    println("分组: $grouped")
}

2. 序列（Sequence）处理大数据集

fun main() {
    val numbers = (1..1_000_000).toList()
    
    // 使用序列避免中间集合创建
    val result = numbers.asSequence()
        .filter { 
            println("Filtering $it")
            it % 2 == 0 
        }
        .map { 
            println("Mapping $it")
            it * it 
        }
        .take(5) // 只取前5个结果
        .toList()
    
    println("结果: $result")
}

三、泛型

泛型允许类、接口和函数操作不同类型的对象。

1. 泛型类

class Box<T>(private val content: T) {
    fun getContent(): T = content
    fun setContent(newContent: T) {
        println("Setting new content: $newContent")
    }
}

fun main() {
    val intBox = Box(42)
    println("Box contains: ${intBox.getContent()}")
    
    val stringBox = Box("Hello Kotlin")
    println("Box contains: ${stringBox.getContent()}")
}

2. 泛型函数

fun <T> printArray(array: Array<T>) {
    for (item in array) {
        print("$item ")
    }
    println()
}

fun main() {
    val intArray = arrayOf(1, 2, 3)
    val stringArray = arrayOf("Kotlin", "Java", "C++")
    
    printArray(intArray)
    printArray(stringArray)
}

3. 泛型约束

// 只允许Number及其子类
fun <T : Number> sum(a: T, b: T): Double {
    return a.toDouble() + b.toDouble()
}

fun main() {
    println("Sum: ${sum(5, 10)}") // 正确
    // println("Sum: ${sum("5", "10")}") // 编译错误
}

4. 泛型接口

interface Repository<T> {
    fun save(item: T)
    fun findById(id: Int): T?
}

class User(val id: Int, val name: String)

class UserRepository : Repository<User> {
    private val users = mutableMapOf<Int, User>()
    
    override fun save(item: User) {
        users[item.id] = item
    }
    
    override fun findById(id: Int): User? {
        return users[id]
    }
}

fun main() {
    val repository = UserRepository()
    repository.save(User(1, "Alice"))
    repository.save(User(2, "Bob"))
    
    println("Found user: ${repository.findById(1)?.name}")
}

四、实战示例：通用数据处理器

// 泛型数据处理器
class DataProcessor<T>(private val data: List<T>) {
    fun process(transformer: (T) -> T): List<T> {
        return data.map(transformer)
    }
    
    fun filter(predicate: (T) -> Boolean): List<T> {
        return data.filter(predicate)
    }
}

fun main() {
    // 处理数字
    val numbers = listOf(1, 2, 3, 4, 5)
    val numberProcessor = DataProcessor(numbers)
    
    val squaredNumbers = numberProcessor.process { it * it }
    println("平方数: $squaredNumbers")
    
    val evenNumbers = numberProcessor.filter { it % 2 == 0 }
    println("偶数: $evenNumbers")
    
    // 处理字符串
    val names = listOf("Alice", "Bob", "Charlie", "David")
    val nameProcessor = DataProcessor(names)
    
    val upperCaseNames = nameProcessor.process { it.uppercase() }
    println("大写名字: $upperCaseNames")
    
    val longNames = nameProcessor.filter { it.length > 4 }
    println("长名字: $longNames")
}

五、总结

集合类型：List有序可重复，Set无序不重复，Map键值对
集合操作：过滤、映射、查找、聚合等常用操作
序列：处理大数据集时更高效
泛型：提供类型安全，避免重复代码
泛型约束：限制泛型类型范围
实战应用：泛型可以创建灵活的数据处理工具
今天分享下Kotlin中集合和泛型的核心概念，这些是构建复杂应用程序的基础。后续我们再来学习下Kotlin的函数式编程特性。