一文掌握kotlin集合中的操作符

一、过滤相关操作符

1、filter

fifter相关的共有如下：
filter:筛选符合条件的元素
filterNot：筛选不符合条件的元素
filterNotNull:过滤掉null值
filterIsInstance：保留指定类型的元素
filterIndexed：相比filter,就是条件函数多了index参数

  val list1 = listOf(1,2,3,4,5,6,7,8)
  val f1 = list1.filter { it > 5 }
  println("@@@ f1 filter :${f1}") // f1=[6, 7, 8]
  val f2 = list1.filterNot { it > 5 }
  println("@@@ f2 filterNot :${f2}") / f2=[1, 2, 3, 4, 5]
  val f3 = list1.filterIndexed { index, i -> index > 3 }
  println("@@@ f3 filterIndexed :${f3}") // f3=[5, 6, 7, 8]
  val list2 = listOf("t1", null,"t2", null, "t3",1,2,4,5)
  val f4  = list2.filterIsInstance<Int>() // 保留指定Int类型
  println("@@@ f4 filterIsInstance: $f4") // 1,2,3,4,5
  val f5 = list2.filterNotNull()
  println("@@@ f5 filterNotNull: $f5") // t1,t2, t3, 1,2,3,4,5

2、take

take(n):返回前n个元素的子集合。若n超过集合大小，返回整个集合
takeLast(n): 返回最后n个元素
takeWhile { 条件}：从首元素开始，持续截取满足条件的元素，遇到第一个不满足条件时立即停止
takeLaskWhile { 条件}: 从未元素开始反向截取满足条件的元素
takeIf { 条件}：若整个集合满足条件，返回原集合，否则返回null

takeUnless: 与takeIf逻辑相反

  val list1 = listOf(1,2,3,4)
  val f1 = list1.take(2)
  println("@@@ f1 take : $f1") // [1,2]
  val f2 = list1.takeLast(2)
  println("@@@ f2 takeLast: $f2") // [3,4]
  val list2 = listOf(1,2,3,4)
  val f3 = list2.takeWhile { it < 3 }
  println("@@@ f3 takeWhile: $f3") // [1,2]
  val f4 = list2.takeIf {it.size == 4} // [1,2,3,4]
  println("@@@ f4 takeWhile: $f4") // [1,2,3,4]
  val f5 = list2.takeUnless { it.size == 2 }
  println("@@@ f5 takeWhile: $f5") // [1,2,3,4]

3、drop

drop(n):跳过前n个元素，返回剩余部分
dropLast(n):跳过最后n个元素
dropWhile { 条件}：从首元素开始跳过满足条件的元素，遇到第一个不满足条件保留剩余所有元素（即使后续元素又满足条件）
dropLastWhile { 条件}：从末元素开始反向跳过满足条件的元素

    val f1 = listOf(1, 2, 3).drop(1) // [2,3]
    println("@@@ f1 drop: $f1 ")
    val f2 = listOf(1,2,3).dropLast(1)
    println("@@@ f2 drop: $f2 ") // [1,2]
    val f3 = listOf(1,2,3,0).dropWhile { it < 3 }
    println("@@@ f3 dropWhile:$f3") // [3,0]
    val f4 = listOf(1,2,3,0).dropLastWhile { it < 3 }
    println("@@@ f4 dropLastWhile: $f4") // [1,2,3]

二、转换操作符

1、map

map用于对集合中的每个元素进行转换，生成一个新的集合

map：对集合中的每个元素应用转换函数（transform：(T) -> R），返回一个新集合List<R>

mapNotNull:自动跳过转换结果为null的元素，返回非空集合

    val numbers  = listOf(1,2,3,4)
    val events = numbers.map { if (it %2 == 0) it * 2 else it}
    println("@@@ map: $events ") // [1,4,3,8]
    val evensNotNull = numbers.mapNotNull { if (it %2 == 0) it else null }
    println("@@@ mapNotNull:$evensNotNull") // [2,4]

2、flatmap?

todo

3、groupBy

用于按条件分组的核心高阶函数，能够将集合根据指定的键(Key)分为多个子集合，返回一个Map<k, List<T>>结构

    val numbers = listOf(1, 2, 3, 4, 5)
    val oddEventGroups = numbers.groupBy { if (it % 2 == 0) "Event" else "Odd" }
    println("@@@ groupBy:$oddEventGroups ") // {Odd=[1, 3, 5], Event=[2, 4]}
    println("@@@ Odd ${oddEventGroups["Odd"]}") // [1,3,5]
    println("@@@ Odd ${oddEventGroups["Event"]}") // [2,4]

三、聚合操作符号

1、reduce/fold

reduce和fold是kotlin 集合中应用聚合计算的核心高阶函数，能够将集合元素合并为单一结果

reduce：从集合第一个元素开始，依次将当前结果与下一元素通过operation合并

Fold：容许指定初始值(inital)，并支持返回类型与集合元素不同（如Int 转String）

    val list = listOf(1,2,3)
    val f1 = list.reduce { acc, i ->  acc * i}
    println("@@@ f1 reduce: $f1") // 6
    val f2 = list.fold(10) {acc, i -> acc + i}
    println("@@ f2 fold: $f2") // 16

2、sum/average/min/max

集合求和、平均值、最小值、最大值

sumBy:根据条件求和

minBy/maxBy:根据条件返回最小/最大值，返回的还是集合原有的类型

data class Person(val name: String, val age:Int)
fun filterDemo() {
    val list = listOf(1, 2, 3, 4, 5)
    println("@@@ sum:${list.sum()}") // 15
    println("@@@ average ${list.average()}") // 3.0
    println("@@@ min :${list.min()}") // 1
    println("@@@ max : ${list.max()}") // 5

    val persons = listOf(Person("Alice", 25), Person("Bob", 30))
    println("@@@ sumBy ${persons.sumOf { it.age }}") //55
    println("@@@ minBy ${persons.minBy { it.age }}") //Person(name=Alice, age=25)
    println("@@@ maxBy ${persons.maxBy { it.age }}") // Person(name=Bob, age=30)
}

四、查找与判断操作符

1、first/last

first和last是kotlin集合操作中用于快速访问首尾元素的核心方法，支持基础检索和条件筛选

first/last:返回集合第一个元素/最后一个元素
first(predicate: (T) ->Boolean):返回满足条件第一个元素
last(predicate: (T) ->Boolean)：返回满足条件最后一个元素
firstOrNull ：无匹配返回null
lastOrNull:无匹配返回null
firstOrNull(predicate: (T) ->Boolean) ：返回满足条件的第一个元素，无匹配时候返回空
lastOrNull(predicate: (T) ->Boolean)：返回满足条件的最后一个元素，无匹配时候返回空

    val numbers = listOf(1, 2, 3, 4, 5)
    val first = numbers.first()
    println("@@@ first :$first") // 1
    val last = numbers.last()
    println("@@@ last :$last") // 5

    val emptyList = emptyList<Int>()
    println("@@@ firstOrNull:${emptyList.firstOrNull()}") // null

    val numbers2s = listOf(1, -2, 3, -4, 5)
    val firstEven = numbers2s.first { it %2 == 0 } 
    val lastEven = numbers2s.last {it < 0} 
    println("@@@ firstEven :$firstEven") // -2
    println("@@@ lastEven :$lastEven") // -4

2、any/all/none

any：检测集合中至少有一个元素满足条件
all:检测集合中所有元素均满足条件（空集合始终返回true,称为”空洞真值“）
none：检测集合中没有元素满足条件（与any 逻辑相反）

    val numbers = listOf(1, 2, 3)
    val f1 = numbers.any { it > 2 }
    println("@@@ f1  $f1") // true
    val words = listOf("cat", "dog")
    val f2 = words.all { it.length == 3 }
    println("@@@ f2  $f2") // true
    val names = listOf("Alice", "Bob")
    val f3 = names.none { it.startsWith("C")}
    println("@@@ f3 $f3") // true

五、排序与去重操作符

1、sort

Kotlin 提供了多种排序操作，用于对集合进行升序，降序或条件排序

sort(): 原地排序（仅用于MutableList)，无返回值
sorted()：返回新列表，原集合不变
sortBy/sortedBy:指定属性排序（升序）
sortByDescending/sortByDescending:按属性降序排序，用法和sortBy/sortedBy

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

fun filterDemo() {
    val mutabltList = mutableListOf(3, 1, 4)
    mutabltList.sort()
    println("@@@ f1 sort :$mutabltList") // [1,3,4]

    val newlist = mutabltList.sorted()
    println("@@@ newlist sort :$newlist") // [1,3,4]

    val persons = listOf(Person("Alice", 30), Person("Bob", 25))
    val newPersons = persons.sortedBy { it.age } // [Person(name=Bob, age=25), Person(name=Alice, age=30)]
    println("@@@ newPersons sort :$newPersons")
    val newPersons2 = persons.sortedBy { it.name }
    println("@@@ newPersons2 sort :$newPersons2")  // [Person(name=Alice, age=25), Person(name=Bob, age=30)]
}

2、distince

用于去重的核心函数，能够快速过滤重复元素并保留唯一值

distinctly:按条件去重

    val list = listOf(1,2,2,3,1)
    val list1 = list.distinct()
    println("@@@ list1 :$list1")
    val fruits = listOf("Apple", "apple")
    val newlist = fruits.distinctBy { it.lowercase() }
    println("@@@ newlist :$newlist")

六、其他

1、zip

用于将两集合按索引一一配对的核心函数，生成一个包含Pair对象的新列表，如果集合长度不一致，

结果列表长度短的为准，多余元素被忽略

    val names = listOf("Alice", "Bob")
    val age = listOf(25,30)
    val paired = names.zip(age)
    println("@@@ zip :$paired") // [("Alice", 25), ("Bob", 30)]

2、partition

用于按条件将集合一份为二的核心函数，返回一个包含两个字集合的Pair，分别存储满足条件和不满足条件的元素

    val numbers = listOf(1, 2, 3, 4, 5)
    val (even, odd) = numbers.partition { it % 2 == 0 }
    println("@@@ even:$even  odd :$odd") // [2,4], [1,3,5]

3、chunked

固定大小块，将集合按指定大小化分为多个子列表（块），最后一个块可能小于指定大小

    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val chunks = numbers.chunked(3)
    println("@@@ chunks :$chunks") // [[1, 2, 3], [4, 5, 6], [7, 8, 9]
    val sums = numbers.chunked(3) {it.sum()}
    println("@@@ sums :$sums") // [6, 15, 24, 10]

4、windowed

生成滑动窗口的子列表，支持重叠窗口和自定义步长，

    // size 窗口大小
    // step：滑动步长（默认为1，表示重叠窗口）
    // partialWindows :是否保留末尾不足窗口大小的子集 默认 false
    val numbers = listOf(1, 2, 3, 4, 5)
    val windows = numbers.windowed(3)
    println("@@@ windows:$windows")
    val nonvoerlap = numbers.windowed(3,3)
    println("@@@ nonvoerlap:$nonvoerlap")
    val withPartial = numbers.windowed(3, partialWindows = true)
    println("@@@ withPartial: $withPartial ")

一文掌握kotlin集合中的操作符