Kotlin 基本用法二

Koltin 集合操作符filter

官方介绍

fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

• predicate：一个 lambda 表达式，接收集合中的元素（类型为 T），返回 Boolean 值（true 表示保留该元素，false 表示过滤该元素）。
• 返回值：包含所有满足条件元素的新 List<T>（原集合不会被修改）。

是不是有点懵，这是啥呀，来，我们看个例子

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

// 筛选出偶数（num % 2 == 0 为 true）
val evenNumbers = numbers.filter { num -> num % 2 == 0 }

println(evenNumbers)  // 输出：[2, 4, 6, 8]

说白了，它就是过滤的作用，我再给你写一个

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

val evenNumbers = numbers.filter { it -> it> 3 }
println(evenNumbers)  // 输出：[4, 5, 6, 7, 8]

你作为一个资深java开发，想想，如果不用filter这个操作符，用java来实现，你要用多少代码

当然还有[filterIndexed()] 它也是可以在遍历的时候，拿到元素的索引

val fruits = listOf("苹果", "香蕉", "橙子", "葡萄", "芒果", "草莓")

// 1. 保留索引为偶数的元素（0、2、4）
val evenIndexFruits = fruits.filterIndexed { index, _ -> 
    index % 2 == 0  // 只关注索引，元素用 _ 忽略
}
println(evenIndexFruits)  // 输出：[苹果, 橙子, 芒果]

// 2. 排除前 2 个元素（索引 < 2 的过滤掉）
val excludeFirstTwo = fruits.filterIndexed { index, _ -> 
    index >= 2 
}
println(excludeFirstTwo)  // 输出：[橙子, 葡萄, 芒果, 草莓]

说到这里，我再介绍一下，kotlin 中针对集合的降序和升序排列，挺实用

一、Kotlin 集合提供了便捷的升序（从小到大）和降序（从大到小）排序操作符，这些操作符基于元素的自然顺序或自定义规则排序，返回新的排序后集合（不可变集合）或直接修改原集合（可变集合）。

这里普及一下，在kotlin中存在 不可变集合 和 可变集合 简单的理解就是， 不可变集合，在初始化化后，不和增删元素 可变集合，反之，可以增删元素

在kotlin 中 可变，mutable 就代表可变的意思。 如果你声明一个List<*> list，那么这个list 声明出来就是不能添加或者删除的，那么你就会问了，它不能增删，它有什么用？ 好问题， 1、它可以在承接接口返回的list数据，比如接口返回一个list集合，你就可以直接承接 2、直接赋值一次，eg：声明了一个var list ： List？ = null, 那么你可以给他赋值一次，即 list = ArrayList（），赋值后，这个list 就不能增删改了

Kotlin 标准库提供了专门的不可变集合接口，位于 kotlin.collections 包下：

• List：不可变列表（对应可变接口 MutableList）
• Set：不可变集合（对应可变接口 MutableSet）
• Map：不可变映射（对应可变接口 MutableMap）

// 使用标准库函数创建不可变集合
val immutableList = listOf(1, 2, 3)
val immutableSet = setOf("a", "b", "c")
val immutableMap = mapOf(1 to "one", 2 to "two")

// 从可变集合创建不可变副本
val mutableList = mutableListOf(1, 2, 3)
val immutableCopy = mutableList.toList() // 转换为不可变列表

-----------------------分割线 -------------------- 俺们继续讨论对集合的升序和降序操作---------

1）、升序

操作符	功能描述	适用场景
sorted()	返回自然升序排序后的新集合（原集合不变）	不可变集合（listOf() 等）
sort()	直接对可变集合进行自然升序排序（修改原集合）	可变集合（mutableListOf()）

// 不可变集合：sorted() 返回新集合
val numbers = listOf(3, 1, 4, 1, 5)
val sortedAsc = numbers.sorted()  // 自然升序
println(sortedAsc)  // 输出：[1, 1, 3, 4, 5]

// 可变集合：sort() 直接修改原集合
val mutableNumbers = mutableListOf(3, 1, 4)
mutableNumbers.sort()  // 原集合被修改
println(mutableNumbers)  // 输出：[1, 3, 4]

2）、 降序排序（从大到小）

操作符	功能描述	适用场景
sortedDescending()	返回自然降序排序后的新集合（原集合不变）	不可变集合（listOf() 等）
sortDescending()	直接对可变集合进行自然降序排序（修改原集合）	可变集合（mutableListOf()）

// 不可变集合：sortedDescending() 返回新集合
val words = listOf("banana", "apple", "cherry")  // String 实现了 Comparable
val sortedDesc = words.sortedDescending()  // 按字母降序（z→a）
println(sortedDesc)  // 输出：[cherry, banana, apple]

// 可变集合：sortDescending() 直接修改原集合
val mutableWords = mutableListOf("banana", "apple")
mutableWords.sortDescending()
println(mutableWords)  // 输出：[banana, apple]

二、自定义规则排序（基于选择器）

操作符	功能描述	适用场景
sortedBy(selector)	按 selector 结果升序排序，返回新集合（原集合不变）	不可变集合
sortBy(selector)	按 selector 结果升序排序，直接修改可变集合	可变集合

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

val people = listOf(
    Person("Bob", 25),
    Person("Alice", 20),
    Person("Charlie", 30)
)

// 按年龄升序（从小到大）
val sortedByAge = people.sortedBy { it.age }
println(sortedByAge)
// 输出：[Person(name=Alice, age=20), Person(name=Bob, age=25), Person(name=Charlie, age=30)]

// 可变集合：sortBy() 直接修改原集合
val mutablePeople = mutableListOf(
    Person("Bob", 25),
    Person("Alice", 20)
)
mutablePeople.sortBy { it.name }  // 按姓名升序（A→Z）
println(mutablePeople)
// 输出：[Person(name=Alice, age=20), Person(name=Bob, age=25)]

同理，还有按照自定义规则的降序，这里就不赘述了

Kotlin 集合的排序操作符按使用场景可分为：

三、总结

排序类型	不可变集合（返回新集合）	可变集合（修改原集合）
自然升序	sorted()	sort()
自然降序	sortedDescending()	sortDescending()
自定义规则升序	sortedBy(selector)	sortBy(selector)
自定义规则降序	sortedByDescending(selector)	sortByDescending(sel

扪心自问下，用java来写，麻不麻烦，人类发明工具的作用就是解放生产力，kotlin 香不香，用完就知道，为什么不用，tell me why？