Kotlin 15. Kotlin List 的使用 2：associateBy，groupBy，partition，flatMap，minOrNull，sorted，zip

一起来学Kotlin：概念：15. Kotlin List 的使用2：associateBy，groupBy，partition，flatMap，minOrNull，sorted，zip，getOrElse

上一章中，我们介绍了 List 函数：

• filter
• map
• count
• first，last
• any, all, none
• find，findLast

这里我们介绍 List 中

• associateBy, groupBy
• partition
• flatMap
• minOrNull, maxOrNull
• sorted，sortedBy
• zip
• getOrElse

---

---

1 associateBy, groupBy

函数 associateBy 和 groupBy 构建来自由指定键索引的集合的元素的映射。key 在 keySelector 参数中定义。我们还可以指定可选的 valueSelector 来定义将存储在 map 元素值中的内容。

区别：associateBy 和 groupBy 之间的区别在于它们如何使用相同的键处理对象：

• associateBy 使用最后一个合适的元素作为值。
• groupBy 构建所有合适元素的列表并将其放入值中。

fun main()
{
    data class Person(val name: String, val city: String, val phone: String) 

    val people = listOf(                                                     
        Person("John", "Boston", "+1-888-123456"),
        Person("Sarah", "Munich", "+49-777-789123"),
        Person("Svyatoslav", "Saint-Petersburg", "+7-999-456789"),
        Person("Vasilisa", "Saint-Petersburg", "+7-999-123456"))

    val phoneBook = people.associateBy { it.phone }                          
    val cityBook = people.associateBy(Person::phone, Person::city)           
    val peopleCities = people.groupBy(Person::city, Person::name)            
    val lastPersonCity = people.associateBy(Person::city, Person::name)      

    println("phoneBook: ${phoneBook}")      // 打印 phoneBook: {+1-888-123456=Person(name=John, city=Boston, phone=+1-888-123456), +49-777-789123=Person(name=Sarah, city=Munich, phone=+49-777-789123), +7-999-456789=Person(name=Svyatoslav, city=Saint-Petersburg, phone=+7-999-456789), +7-999-123456=Person(name=Vasilisa, city=Saint-Petersburg, phone=+7-999-123456)}
    println("cityBook: ${cityBook}")        // 打印 cityBook: {+1-888-123456=Boston, +49-777-789123=Munich, +7-999-456789=Saint-Petersburg, +7-999-123456=Saint-Petersburg}
    println("peopleCities: ${peopleCities}")    // 打印 peopleCities: {Boston=[John], Munich=[Sarah], Saint-Petersburg=[Svyatoslav, Vasilisa]}
    println("lastPersonCity: ${lastPersonCity}")    // 打印 lastPersonCity: {Boston=John, Munich=Sarah, Saint-Petersburg=Vasilisa}
}

2 partition

partition函数通过给定的条件将原始的列表一分为二。

fun main()
{
    val numbers = listOf(1, -2, 3, -4, 5, -6)                
    val evenOdd = numbers.partition { it % 2 == 0 }             
    val (positives, negatives) = numbers.partition { it > 0 }   

    println("evenOdd: ${evenOdd}")          // 打印 evenOdd: ([-2, -4, -6], [1, 3, 5])
    println("positives: ${positives}")      // 打印 positives: [1, 3, 5]
    println("negatives: ${negatives}")      // 打印 negatives: [-2, -4, -6]
}

3 flatMap

flatMap 将列表集合的每个元素转换为可迭代对象，并生成转换结果的单个列表。

fun main()
{
    val fruitsBag = listOf("apple","orange","banana","grapes")  
    val clothesBag = listOf("shirts","pants","jeans")           
    val cart = listOf(fruitsBag, clothesBag)                    
    val mapBag = cart.map { it }                                
    val flatMapBag = cart.flatMap { it } 

    println("cart: ${cart}")        // 打印 cart: [[apple, orange, banana, grapes], [shirts, pants, jeans]]  
    println("mapBag: ${mapBag}")    // 打印 mapBag: [[apple, orange, banana, grapes], [shirts, pants, jeans]]
    println("flatMapBag: ${flatMapBag}")    // 打印 flatMapBag: [apple, orange, banana, grapes, shirts, pants, jeans]
}

4 minOrNull, maxOrNull

就像字面意思所描述的，minOrNull 以及 maxOrNull 返回列表集合的最小和最大元素。如果集合为空，则返回 null。

fun main()
{
    val numbers = listOf(1, 2, 3)
    val empty = emptyList<Int>()
    val only = listOf(3)

    println("Numbers: $numbers, min = ${numbers.minOrNull()} max = ${numbers.maxOrNull()}")            // 打印 Numbers: [1, 2, 3], min = 1 max = 3
    println("Empty: $empty, min = ${empty.minOrNull()}, max = ${empty.maxOrNull()}")            // 打印 Empty: [], min = null, max = null
    println("Only: $only, min = ${only.minOrNull()}, max = ${only.maxOrNull()}")            // 打印 Only: [3], min = 3, max = 3
}

5 sorted，sortedBy

sorted 返回根据其自然排序顺序（升序）排序的集合元素的列表。sortedBy 根据某些条件对元素进行排序。

import kotlin.math.abs

fun main() {

    val shuffled = listOf(5, 4, 2, 1, 3, -10)                   
    val natural = shuffled.sorted()                             
    val inverted = shuffled.sortedBy { -it }                    
    val descending = shuffled.sortedDescending()                
    val descendingBy = shuffled.sortedByDescending { abs(it)  } 

    println("Shuffled: $shuffled")          // 打印 Shuffled: [5, 4, 2, 1, 3, -10]
    println("Natural order: $natural")      // 打印 Natural order: [-10, 1, 2, 3, 4, 5]
    println("Inverted natural order: $inverted")    // 打印 Inverted natural order: [5, 4, 3, 2, 1, -10]
    println("Inverted natural order value: $descending")    // 打印 Inverted natural order value: [5, 4, 3, 2, 1, -10]
    println("Inverted natural order of absolute values: $descendingBy") // 打印 Inverted natural order of absolute values: [-10, 5, 4, 3, 2, 1]
}

6 zip

zip 函数将两个给定集合合并到一个新集合中。默认情况下，结果集合包含具有相同索引的源集合元素对。但是，我们可以定义自己的结果集合元素的结构。

fun main() {

    val A = listOf("a", "b", "c")                  
    val B = listOf(1, 2, 3, 4)                     
    val resultPairs = A zip B                      
    val resultReduce = A.zip(B) { a, b -> "$a$b" } 

    println("A to B: $resultPairs")     // 打印 A to B: [(a, 1), (b, 2), (c, 3)]
    println("\$A\$B: $resultReduce")    // 打印 $A$B: [a1, b2, c3]
}

7 getOrElse

getOrElse 采用索引来 get 列表集合中的某个元素，如果该索引超出列表的最大长度，那么会返回提供的一个默认值。

fun main() {
    val list = listOf(0, 10, 20)
    println(list.getOrElse(1) { 42 })    // 打印 10
    println(list.getOrElse(10) { 42 })   // 打印 42
}

getOrElse 也可以被用于 Map 中来获取 key 对应的 value。

fun main() {

    val map = mutableMapOf<String, Int?>()
    println(map.getOrElse("x") { 1 })       // 打印 1

    map["x"] = 3
    println(map.getOrElse("x") { 1 })       // 打印 3

    map["x"] = null
    println(map.getOrElse("x") { 1 })       // 打印 1
}