kotlin集合扩展函数【学习笔记】

映射

map

说明：将每个元素转换为另一种形式，并返回一个包含转换后元素的新列表。

示例：根据person列表获取到所有person的姓名并返回列表

 data class Person(val name: String, val age: Int)// 实体类   
 fun test() {
        val persons = listOf(
            Person("Alice", 30),
            Person("Bob", 25),
            Person("John", 20),
            Person("Jane", 35),
            Person("John", 28)
        )
        println(persons.map { it.name })
    }

打印结果：

[Alice, Bob, John, Jane, John]

map函数还经常结合协程、async进行使用。比如需要进行文件分片下载，并得到所有分片数据。

示例：

 @Test
    fun testDownload() {
        runBlocking {
            downloadFile()
        }
    }
    
    suspend fun downloadFile() = withContext(Dispatchers.IO){
        // 假设已知需要下载文件的文件片数
        val totalPieces = 10
        val allPartList =(1..totalPieces).map { index ->
            async{// 进行异步下载
                downloadPart(index)
            }
        }.awaitAll()// 收集下载结果(按1-10顺序的结果)
        println(allPartList)
    }

    private fun downloadPart(partNumber:Int):String{
        val result = "第${partNumber}片文件base64字符串"
        return result
    }

 输出结果：

[第1片文件base64字符串, 第2片文件base64字符串, 第3片文件base64字符串, 第4片文件base64字符串, 第5片文件base64字符串, 第6片文件base64字符串, 第7片文件base64字符串, 第8片文件base64字符串, 第9片文件base64字符串, 第10片文件base64字符串]

mapIndexed

说明：与map类似，区别在于回调方法中有两个参数，一个参数为下标索引，另一个参数为对应的元素。

示例： 根据person集合得到student集合

data class Person(val name: String, val age: Int)
data class Student(val id: Int, val name: String, val age: Int)    
fun test() {
        val persons = listOf(
            Person("Alice", 30),
            Person("Bob", 25),
            Person("John", 20),
            Person("Jane", 35),
            Person("John", 28)
        )
        val students = persons.mapIndexed { index, person ->
            Student(index, person.name, person.age)
        }
        println(students)
    }

打印结果：

[Student(id=0, name=Alice, age=30), Student(id=1, name=Bob, age=25), Student(id=2, name=John, age=20), Student(id=3, name=Jane, age=35), Student(id=4, name=John, age=28)]

 为了不过多占用文章篇幅，后续所有persons皆为：

 val persons = listOf(
            Person("Alice", 30),
            Person("Bob", 25),
            Person("John", 20),
            Person("Jane", 35),
            Person("John", 28)
        )

过滤

filter

说明：用于根据给定的条件筛选列表中的元素，并返回符合条件的元素组成的新列表。

示例：获取person列表中年龄大于等于30的，并返回列表

 val result = persons.filter { it.age>=30 }
 println(result)

打印结果：

[Person(name=Alice, age=30), Person(name=Jane, age=35)]

filterNot

说明：用于根据给定的条件筛选列表中的元素，并返回不符合条件的元素组成的新列表，得到的结果与filter方法相反

示例：获取姓名中不包含J的person，并返回列表

 val result = persons.filterNot { it.name.contains("J") }
 println(result)

打印结果：

[Person(name=Alice, age=30), Person(name=Bob, age=25)]

filterNotNull

说明：筛选非空元素，与filterNot类似，如果不存在返回空

 排序

sorted

说明：按自然顺序升序排序

示例：

val numbers = listOf(5, 3, 8, 1)
val sortedNumbers = numbers.sorted()
println(sortedNumbers) // 输出: [1, 3, 5, 8]

sortedBy

说明：按指定条件进行升序排序，如果需要降序结果可以使用sortedDescending函数，或者排列后再使用reversed

示例：

val sortedResult = persons.sortedBy { it.age }
println(sortedResult)

打印结果：

[Person(name=John, age=20), Person(name=Bob, age=25), Person(name=John, age=28), Person(name=Alice, age=30), Person(name=Jane, age=35)] 

sortedDescending

说明：与sortedBy用法相似，但是结果为降序排列

 persons.sortedDescending { it.age }// 对person列表按年龄降序排列

效果等同于： 

persons.sortedBy { it.age }.reversed()

shuffle

说明：shuffle是洗牌的意思，顾名思义就是对列表进行随机排列，很少用到，不举例

reversed

说明：列表中的元素顺序颠倒

示例：

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

打印结果：

[5, 4, 3, 2, 1]

获取值

maxByOrNull

说明：返回产生给定函数的最大值的第一个元素，或者 null 如果没有元素，则返回该元素

示例：获取persons列表中年龄最大的元素

  val result = persons.maxByOrNull{ it.age}
  println(result)

 效果等同于：

persons.sortedBy { it.age }.lastOrNull()

因为sortedBy是按升序排列，最后一项如果存在就是最大的那一项 

indexOfFirst、indexOfLast

 说明：分别为查找第一个和最后一个满足条件元素的索引，如果不存在，返回-1

示例：

 fun test() {
        val numbers = listOf(1, 2, 1)
        println("查找第一个满足条件的下标：${numbers.indexOfFirst { it == 1 }}")
        println("查找第一个满足条件的下标-查找元素不存在：${numbers.indexOfFirst { it == 3 }}")
        println("查找最后一个满足条件元素的下标：${numbers.indexOfLast { it == 1 }}")
        println("查找最后一个满足条件元素的下标-查找元素不存在：${numbers.indexOfLast { it == 3 }}")
    }

打印结果：

查找第一个满足条件的下标：0
查找第一个满足条件的下标-查找元素不存在：-1
查找最后一个满足条件元素的下标：2
查找最后一个满足条件元素的下标-查找元素不存在：-1

lastIndexOf

说明：查找指定元素的最后一个索引

示例：

val numbers = listOf(1,2,1)
println(numbers.lastIndexOf(1))

打印结果：

2

分组和分区

groupBy

  说明：根据指定的键选择器，将元素分组为一个 Map。

示例：

  data class Student( val name: String, val major: String)
    fun test() {
        val students = listOf(
           Student("Alice","C语言" ),
           Student("Bob", "C语言"),
           Student("John", "Java"),
           Student("Jane", "Python"),
           Student("John", "Python")
        )

        val result = students.groupBy { it.major }

        println("分组结果:${result}")
        val groupedList = result.values.toList()
        println("分组后的列表数量：${groupedList.size}")
        println("分组后的列表：$groupedList")
    }

打印结果：

分组结果:{C语言=[Student(name=Alice, major=C语言), Student(name=Bob, major=C语言)], Java=[Student(name=John, major=Java)], Python=[Student(name=Jane, major=Python), Student(name=John, major=Python)]}
分组后的列表数量：3
分组后的列表：[

[Student(name=Alice, major=C语言), Student(name=Bob, major=C语言)], [Student(name=John, major=Java)],

[Student(name=Jane, major=Python), Student(name=John, major=Python)]

]

partition

说明：将一个列表按照指定条件拆分为两个列表，得到Pair对象，其中一个为满足条件的集合，另一个为不满足条件的集合

示例：

  val pair = persons.partition { it.age > 25 }
  println("满足条件的结果：${pair.first}")
  println("不满足条件的结果:${pair.second}")

 打印结果：

满足条件的结果：[Person(name=Alice, age=30), Person(name=Jane, age=35), Person(name=John, age=28)]
不满足条件的结果:[Person(name=Bob, age=25), Person(name=John, age=20)]

判断

none

说明： 检查列表中的元素是否都不符合给定的条件。如果列表中没有任何元素符合该条件，则返回 true，否则返回 false。

示例1：判断persons中是否有年龄都大于(小于)20的元素

 println("没有大于20的：${persons.none { it.age > 20 }}")
 println("没有小于20的：${persons.none { it.age < 20 }}")

打印结果：

没有大于20的：false
没有小于20的：true