【Kotlin】集合操作

背景

在经过一段时间的kotlin实践后，发现它真的很适合我们当前的业务场景，一方面它可以和Java无缝结合，兼容老业务，另一方面，由于经常需要对数据集合做各种遍历转换的操作，而kotlin在这方面的提供了比Java更加简洁、易读的函数。

集合类型

跟Java类似，在Kotlin中，常用的集合有如下三类：

• List
• Set
• Map

根据集合是否只读，在创建集合时又可划分为：Read-only Collections 和 Mutable Collections 两种

• Read-only Collections
  • listOf():
  • setOf()
  • mapOf()

fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    val set = setOf(1, 1, 3, 4, 5)
    val map = mapOf(1 to "a", 2 to "b")
    println(list.toString())
    println(set.toString())
    println(map.toString())
}

// result
[1, 2, 3, 4, 5]
[1, 3, 4, 5]
{1=a, 2=b}

• Mutable Collections
  • mutableListOf()
  • MutableSetOf()
  • mutableMapOf()

val list1 = mutableListOf(1, 2, 3, 4, 5)
    list1.add(6)
    val set1 = mutableSetOf(1, 1, 3, 4, 5)
    set1.add(6)
    val map1 = mutableMapOf(1 to "a", 2 to "b")
    map1[3] = "C"
// result
    println(list.toString())
    println(set.toString())
    println(map1.toString())

集合操作

记录一些业务常用的集合操作：

加减操作

val list2 = listOf(1, 2, 3, 4, 5)
    
    val ans1 = list2 +  listOf(1, 2, 3, 4, 5)
    val ans2 = list2 - mutableListOf(1, 2)

    println(ans1.toString())
    println(ans2.toString())

// result
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
[3, 4, 5]

并集

 val list2 = listOf(1, 2, 3, 4, 5)
    val ans3 = list2.union(listOf(6))
    println("并集： $ans3")
// result
并集： [1, 2, 3, 4, 5, 6]

交集

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

// 使用 intersect 函数获取交集
    val intersection = list2.intersect(listOf(1, 2, 3))
    println("交集： $intersection")

// result
交集： [1, 2, 3]

集合分组

• groupBy：分组后，value会是一个列表，出现相同key时，value会在一个列表中。
• associateBy：出现相同key时，value只会有一个

 val list2 = listOf(1, 1, 2, 3, 4, 5)
    val ans4 = list2.groupBy { it }
    val ans5 = list2.associateBy { it }
    println("groupBy： $ans4")
    println("associateBy： $ans5")
// result
groupBy： {1=[1, 1], 2=[2], 3=[3], 4=[4], 5=[5]}
associateBy： {1=1, 2=2, 3=3, 4=4, 5=5}

集合转换

flatMap

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

// 使用 flatMap() 将嵌套列表展平为单个列表
    val flatList = list.flatMap { it }
    println(flatList) // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

flatMapIndexed

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

// 使用 flatMapIndexed() 将嵌套列表展平为单个列表，并保留索引
    val flatListIndexed = list.flatMapIndexed { index, sublist -> sublist.map {
     	index to it 
     } }
    println(flatListIndexed) 
  // 输出: [(0, 1), (0, 2), (0, 3), (1, 4), (1, 5), (1, 6), (2, 7), (2, 8), (2, 9)]

flatMapTo

  val list = listOf(listOf(1, 2, 3), listOf(4, 5, 6), listOf(7, 8, 9))
    
// 使用 flatMapTo() 将嵌套列表展平为单个列表，并将结果添加到指定集合中
    val flatListTo = mutableListOf<Int>()
    list.flatMapTo(flatListTo) { it }
    println(flatListTo) // 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

mapIndexed

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

// 使用 mapIndexed() 对列表中的元素进行索引转换
    val mappedListIndexed = list.mapIndexed { index, sublist -> sublist.map {
     	index to it 
     } }
    println(mappedListIndexed) 
// 输出: 
//[[(0, 1), (0, 2), (0, 3)], [(1, 4), (1, 5), (1, 6)], [(2, 7), (2, 8), (2, 9)]]

mapIndexedTo

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

    // 对列表中的元素进行索引转换 并赋值到一个新列表，
    val multipliedList = mutableListOf<List<Pair<Int, Int>>>()
    list.mapIndexedTo(multipliedList) { index, value -> value.map {
        index to it
    } }
// [[(0, 1), (0, 2), (0, 3)], [(1, 4), (1, 5), (1, 6)], [(2, 7), (2, 8), (2, 9)]]

reduceIndexed

count： 默认情况下，取列表的第一个元素为初始值, 每次计算结果为保存在count

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

    // 使用 reduceIndexed 计算每个元素与其索引的乘积之和
    val product = numbers.reduceIndexed { index, count, value ->
        println(count)  // 2 4 10 22
        count + (index * value)
    }
    // 42

flatten

val nestedList = listOf(listOf(1, 2, 3), listOf(4, 5), listOf(6, 7, 8))

    // 使用 flatten 将嵌套列表平铺
    val flatList = nestedList.flatten()

  // 平铺列表: [1, 2, 3, 4, 5, 6, 7, 8]