Kotlin 集合概述 #

// 只读 List
val readOnlyList: List<Int> = listOf(1, 2, 3)

// 只读 Set
val readOnlySet: Set<Int> = setOf(1, 2, 3)

// 只读 Map
val readOnlyMap: Map<String, Int> = mapOf("a" to 1, "b" to 2)

// 可变 List
val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)
mutableList.add(4)

// 可变 Set
val mutableSet: MutableSet<Int> = mutableSetOf(1, 2, 3)
mutableSet.add(4)

// 可变 Map
val mutableMap: MutableMap<String, Int> = mutableMapOf("a" to 1)
mutableMap["b"] = 2

Collection (只读)
    ├── List
    ├── Set
    └── Map (不是 Collection 的子接口)

MutableCollection (可变)
    ├── MutableList
    ├── MutableSet
    └── MutableMap

// 空列表
val empty = emptyList<Int>()

// 只读列表
val list = listOf(1, 2, 3)

// 可变列表
val mutable = mutableListOf(1, 2, 3)

// 使用 List 构造函数
val list2 = List(5) { it * 2 }  // [0, 2, 4, 6, 8]

// ArrayList
val arrayList = arrayListOf(1, 2, 3)

// 空集合
val empty = emptySet<Int>()

// 只读集合
val set = setOf(1, 2, 3)

// 可变集合
val mutable = mutableSetOf(1, 2, 3)

// LinkedHashSet（保持插入顺序）
val linked = linkedSetOf(1, 2, 3)

// TreeSet（排序）
val sorted = sortedSetOf(3, 1, 2)  // [1, 2, 3]

// HashSet
val hash = hashSetOf(1, 2, 3)

// 空映射
val empty = emptyMap<String, Int>()

// 只读映射
val map = mapOf("a" to 1, "b" to 2)

// 可变映射
val mutable = mutableMapOf("a" to 1, "b" to 2)

// LinkedHashMap（保持插入顺序）
val linked = linkedMapOf("a" to 1, "b" to 2)

// TreeMap（按键排序）
val sorted = sortedMapOf("c" to 3, "a" to 1, "b" to 2)

// HashMap
val hash = hashMapOf("a" to 1, "b" to 2)

val list = listOf(1, 2, 3)

// 转为 Set
val set = list.toSet()

// 转为 MutableSet
val mutableSet = list.toMutableSet()

// 转为 Map
val map = list.associateBy { it }

val set = setOf(1, 2, 3)

// 转为 List
val list = set.toList()

// 转为 MutableList
val mutableList = set.toMutableList()

val map = mapOf("a" to 1, "b" to 2)

// 转为 List
val list = map.toList()  // [(a, 1), (b, 2)]

// 获取键列表
val keys = map.keys.toList()

// 获取值列表
val values = map.values.toList()

val list = listOf<Int>()

list.isEmpty()      // true
list.isNotEmpty()   // false
list.empty()        // true（Kotlin 1.3+）

val list = listOf(1, 2, 3)

list.contains(2)    // true
2 in list           // true
list.containsAll(listOf(1, 2))  // true

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

list.any { it > 3 }     // true（存在满足条件的元素）
list.all { it > 0 }     // true（所有元素满足条件）
list.none { it < 0 }    // true（没有元素满足条件）

val list = listOf("A", "B", "C")

for (item in list) {
    println(item)
}

for ((index, item) in list.withIndex()) {
    println("$index: $item")
}

val list = listOf("A", "B", "C")

list.forEach { println(it) }

list.forEachIndexed { index, item ->
    println("$index: $item")
}

val list = listOf(1, 2, 3)

val iterator = list.iterator()
while (iterator.hasNext()) {
    println(iterator.next())
}

val map = mapOf("a" to 1, "b" to 2)

// 遍历键值对
for ((key, value) in map) {
    println("$key -> $value")
}

// 遍历键
for (key in map.keys) {
    println(key)
}

// 遍历值
for (value in map.values) {
    println(value)
}

val list = listOf(1, 2, 3, 4, 5)
val set = setOf(1, 2, 3)
val map = mapOf("a" to 1, "b" to 2)

list.size    // 5
set.size     // 3
map.size     // 2

val list1 = listOf(1, 2, 3)
val list2 = listOf(1, 2, 3)
val list3 = listOf(3, 2, 1)

list1 == list2  // true（内容相等）
list1 == list3  // false

val set1 = setOf(1, 2, 3)
val set2 = setOf(3, 2, 1)

set1 == set2  // true（Set 不关心顺序）

data class Person(val name: String, val age: Int, val city: String)

val people = listOf(
    Person("Alice", 25, "Beijing"),
    Person("Bob", 30, "Shanghai"),
    Person("Charlie", 25, "Beijing")
)

// 按城市分组
val byCity = people.groupBy { it.city }
// {Beijing=[Alice, Charlie], Shanghai=[Bob]}

// 按年龄分组
val byAge = people.groupBy { it.age }
// {25=[Alice, Charlie], 30=[Bob]}

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

val stats = mapOf(
    "count" to numbers.size,
    "sum" to numbers.sum(),
    "average" to numbers.average(),
    "max" to numbers.maxOrNull()!!,
    "min" to numbers.minOrNull()!!
)

data class Product(val name: String, val price: Double, val category: String)

val products = listOf(
    Product("Apple", 5.0, "Fruit"),
    Product("Banana", 3.0, "Fruit"),
    Product("Milk", 10.0, "Dairy")
)

// 过滤水果
val fruits = products.filter { it.category == "Fruit" }

// 价格大于 4 的产品
val expensive = products.filter { it.price > 4.0 }

// 推荐
val list: List<Int> = listOf(1, 2, 3)

// 只在需要修改时使用可变集合
val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)

// 推荐
val list = listOf(1, 2, 3)

// 不推荐
val list: List<Int> = listOf(1, 2, 3)

// 推荐
val result = list.filter { it > 0 }.map { it * 2 }

// 不推荐
val result = mutableListOf<Int>()
for (item in list) {
    if (item > 0) {
        result.add(item * 2)
    }
}