背景

在经过一段时间的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"
// resultprintln(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 22count + (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]