Kotlin 集合操作 #

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

val evens = numbers.filter { it % 2 == 0 }
// [2, 4, 6, 8, 10]

val greaterThan5 = numbers.filter { it > 5 }
// [6, 7, 8, 9, 10]

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

val result = numbers.filterNot { it % 2 == 0 }
// [1, 3, 5]

val list = listOf("a", "b", "c", "d", "e")

val result = list.filterIndexed { index, _ -> index % 2 == 0 }
// [a, c, e]

val list = listOf(1, null, 2, null, 3)

val result = list.filterNotNull()
// [1, 2, 3]

val list: List<Any> = listOf(1, "a", 2, "b", 3)

val strings = list.filterIsInstance<String>()
// [a, b]

val ints = list.filterIsInstance<Int>()
// [1, 2, 3]

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

list.take(3)           // [1, 2, 3]
list.takeLast(3)       // [3, 4, 5]
list.drop(2)           // [3, 4, 5]
list.dropLast(2)       // [1, 2, 3]

// 条件版本
list.takeWhile { it < 4 }    // [1, 2, 3]
list.dropWhile { it < 3 }    // [3, 4, 5]

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

val doubled = numbers.map { it * 2 }
// [2, 4, 6, 8, 10]

val strings = numbers.map { "Number: $it" }
// [Number: 1, Number: 2, ...]

val list = listOf("a", "b", "c")

val result = list.mapIndexed { index, value -> "$index: $value" }
// [0: a, 1: b, 2: c]

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

val result = list.mapNotNull { 
    if (it > 2) it * 2 else null 
}
// [6, 8, 10]

val lists = listOf(listOf(1, 2), listOf(3, 4), listOf(5, 6))

val result = lists.flatMap { it }
// [1, 2, 3, 4, 5, 6]

val words = listOf("Hello", "World")
val chars = words.flatMap { it.toList() }
// [H, e, l, l, o, W, o, r, l, d]

val list = listOf("a", "bb", "ccc")

val map = list.associateWith { it.length }
// {a=1, bb=2, ccc=3}

val map2 = list.associateBy { it.length }
// {1=a, 2=bb, 3=ccc}

val map3 = list.associate { it to it.length }
// {a=1, bb=2, ccc=3}

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

val sorted = numbers.sorted()
// [1, 1, 2, 3, 4, 5, 6, 9]

val sortedDesc = numbers.sortedDescending()
// [9, 6, 5, 4, 3, 2, 1, 1]

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

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

val byAge = people.sortedBy { it.age }
// [Person(Alice, 25), Person(Bob, 30), Person(Charlie, 35)]

val byName = people.sortedBy { it.name }
// [Person(Alice, 25), Person(Bob, 30), Person(Charlie, 35)]

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

val result = people.sortedWith(
    compareBy({ it.age }, { it.name })
)
// 先按年龄排序，年龄相同按名字排序

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

list.reversed()        // [5, 4, 3, 2, 1]
list.shuffled()        // 随机打乱

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

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

val byAge = people.groupBy { it.age }
// {25=[Alice, Charlie], 30=[Bob, David]}

val namesByAge = people.groupBy({ it.age }, { it.name })
// {25=[Alice, Charlie], 30=[Bob, David]}

val words = listOf("apple", "banana", "cherry", "date")

val countByLength = words.groupingBy { it.length }.eachCount()
// {5=1, 6=2, 4=1}

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

val chunks = list.chunked(3)
// [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

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

val (evens, odds) = numbers.partition { it % 2 == 0 }
// evens = [2, 4, 6]
// odds = [1, 3, 5]

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

val sum = numbers.reduce { acc, n -> acc + n }
// 15

val product = numbers.reduce { acc, n -> acc * n }
// 120

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

val sum = numbers.fold(0) { acc, n -> acc + n }
// 15

val sumWithInitial = numbers.fold(10) { acc, n -> acc + n }
// 25

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

numbers.sum()          // 15
numbers.average()      // 3.0
numbers.maxOrNull()    // 5
numbers.minOrNull()    // 1
numbers.count()        // 5
numbers.count { it > 3 }  // 2

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

val products = listOf(
    Product("A", 10.0),
    Product("B", 20.0),
    Product("C", 30.0)
)

val total = products.sumOf { it.price }
// 60.0

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

numbers.find { it > 3 }        // 4
numbers.findLast { it < 4 }    // 3
numbers.findOrNull { it > 10 } // null

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

numbers.any { it > 3 }     // true
numbers.all { it > 0 }     // true
numbers.none { it < 0 }    // true

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

list.indexOf(2)            // 1
list.lastIndexOf(2)        // 3
list.indexOfFirst { it > 2 }  // 2
list.indexOfLast { it < 4 }   // 3

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

val unique = list.distinct()
// [1, 2, 3, 4]

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

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

val byAge = people.distinctBy { it.age }
// [Person(Alice, 25), Person(Charlie, 30)]

val names = listOf("Alice", "Bob", "Charlie")
val ages = listOf(25, 30, 35)

val pairs = names.zip(ages)
// [(Alice, 25), (Bob, 30), (Charlie, 35)]

val maps = names.zip(ages) { name, age -> "$name: $age" }
// [Alice: 25, Bob: 30, Charlie: 35]

val pairs = listOf("a" to 1, "b" to 2, "c" to 3)

val (keys, values) = pairs.unzip()
// keys = [a, b, c]
// values = [1, 2, 3]

val map1 = mapOf("a" to 1, "b" to 2)
val map2 = mapOf("b" to 3, "c" to 4)

val merged = map1 + map2
// {a=1, b=3, c=4}

data class Order(val id: Int, val amount: Double, val status: String)

val orders = listOf(
    Order(1, 100.0, "completed"),
    Order(2, 50.0, "pending"),
    Order(3, 200.0, "completed"),
    Order(4, 75.0, "cancelled")
)

val totalCompleted = orders
    .filter { it.status == "completed" }
    .map { it.amount }
    .sum()
// 300.0

data class Sale(val product: String, val amount: Double, val region: String)

val sales = listOf(
    Sale("A", 100.0, "East"),
    Sale("B", 200.0, "West"),
    Sale("A", 150.0, "East"),
    Sale("B", 250.0, "West")
)

val byProduct = sales
    .groupBy { it.product }
    .mapValues { (_, list) -> list.sumOf { it.amount } }
// {A=250.0, B=450.0}