Kotlin日常使用函数记录

前言

记录一些kotlin开发中，日常使用的函数和方式之类的，不然有时候总是忘，还得去翻官方文档或者API，必须集合转Map的方式，我总是忘 。。。😭

会不定时进行记录更新，文章也会越来越完善。

字符串

集合

1.两个集合的差集

集合1和集合2，获取集合1中有，但是集合2中没有的

fun main() {
    val collection1 = listOf(1, 2, 3, 4, 5)
    val collection2 = listOf(3, 4, 5, 6, 7)

    // 使用 minus 操作符计算差集
    val difference = collection1 - collection2
    println("使用 minus 操作符计算的差集: $difference")
}    

2.集合转数组

在 Kotlin 中，可以将集合转换为数组，根据集合元素类型的不同，转换方式也有所不同。这里分别介绍将集合转换为基本数据类型数组和对象数组的方法。

2.1.集合转基本数据类型数组

对于基本数据类型（如 Int、Double 等）的集合，需要使用特定的方法进行转换。Kotlin 提供了相应的转换方法，如 toIntArray()、toDoubleArray()、toLongArray() 等。

集合转 IntArray，使用 toIntArray() 方法将包含 Int 元素的集合转换为 IntArray。

fun main() {
    // 创建一个整数集合
    val intList = listOf(1, 2, 3, 4, 5)

    // 将集合转换为 IntArray
    val intArray: IntArray = intList.toIntArray()
}    

集合转 DoubleArray，使用 toDoubleArray() 方法将包含 Double 元素的集合转换为 DoubleArray。

fun main() {
    // 创建一个双精度浮点数集合
    val doubleList = listOf(1.1, 2.2, 3.3, 4.4, 5.5)

    // 将集合转换为 DoubleArray
    val doubleArray: DoubleArray = doubleList.toDoubleArray()
}    

2.2.集合转对象数组

使用 toTypedArray() 方法可以将任意类型的集合转换为对应的对象数组。

fun main() {
    // 创建一个字符串集合
    val stringList = listOf("apple", "banana", "cherry")

    // 将集合转换为对象数组
    val stringArray: Array<String> = stringList.toTypedArray()
}    

这里使用了String类型的数组，实际中可以是任何对象，例如你自己定义的UserDTO等对象。

2.3.集合转Map

Kotlin 标准库提供了几种以 associate 开头的方法，用于将集合转换为映射(Map)。

• associateWith： 创建一个映射，其中原始集合的元素作为键，通过给定的转换函数生成值。

val numbers = listOf("one", "two", "three")
val map = numbers.associateWith { it.length }
println(map) // 输出: {one=3, two=3, three=5}

• associateBy： 创建一个映射，其中原始集合的元素作为值，通过给定的转换函数生成键。如果有多个元素生成相同的键，则最后一个元素会覆盖前面的。

val numbers = listOf("one", "two", "three")
val map = numbers.associateBy { it.first().uppercase() }
println(map) // 输出: {O=one, T=three} (注意: 'two' 也被 T 开头，但被覆盖)

• associate： 最通用的方法，将集合元素转换为键值对。

val names = listOf("Alice", "Bob", "Carol")
val map = names.associate { name -> name to name.length }
println(map) // 输出: {Alice=5, Bob=3, Carol=5}

3.unzip方法

在 Kotlin 中，unzip() 是一个扩展函数，用于将 List<Pair<T, R>>（即元素为 Pair 的集合）拆分成两个独立的列表：一个包含所有 Pair 的第一个元素，另一个包含所有 Pair 的第二个元素。

• 输入：List<Pair<T, R>>（例如 List<Pair<String, Int>>）
• 输出：Pair<List, List>（例如 Pair<List, List>）

val users = listOf(
    User("Alice", 25),
    User("Bob", 30),
    User("Charlie", 22)
)

// 1. 使用 `map` 将 `List<User>` 转为 `List<Pair<String, Int>>`
val nameAgePairs = users.map { it.name to it.age }
// 结果: [("Alice", 25), ("Bob", 30), ("Charlie", 22)]

// 2. 使用 `unzip()` 拆分成两个独立的列表
val (names, ages) = nameAgePairs.unzip()
// names: ["Alice", "Bob", "Charlie"]
// ages: [25, 30, 22]

Map

1.合并Map

在 Kotlin 里，合并两个 Map 有多种方式。

1.1.使用 + 操作符

此操作符能合并两个Map，若有重复键，后面 Map 的值会覆盖前面的。结果是生成一个新的Map。

fun main() {
    // 两个Map是不是可变的Map无所谓
    val map1 = mutableMapOf("a" to 1, "b" to 2)
    val map2 = mapOf("b" to 3, "c" to 4)
    val mergedMap = map1 + map2
    println(mergedMap)
}    

使用 plus 函数和 + 操作符作用相同。

fun main() {
    val map1 = mapOf("a" to 1, "b" to 2)
    val map2 = mapOf("b" to 3, "c" to 4)
    val mergedMap = map1.plus(map2)
    println(mergedMap)
}    

1.2.使用 += 操作符

在有可变 map 的场景下，我们可以使用已有的 map 来保存合并两个 map 后的结果。

fun main() {
	val map1 = mutableMapOf("a" to 1, "b" to 2)
	val map2 = mapOf("b" to 3, "c" to 4)
	map1 += map2
	println(map1 )
}

1.3.使用 putAll 方法

putAll 方法会把第二个 Map 的键值对添加到第一个可变 Map 中，重复键的值会被覆盖。要求第一个Map必须是可变Map，否则不能调用putAll方法。

fun main() {
    val mutableMap1 = mutableMapOf("a" to 1, "b" to 2)
    val map2 = mapOf("b" to 3, "c" to 4)
    mutableMap1.putAll(map2)
    println(mutableMap1)
}    

1.4.使用 merge 函数

若有重复键，想自定义处理方式，可使用 merge 函数。

例如，合并两个Map的时候，重复键的值进行相加。

fun main() {
	// 这里的map1需要是可变的
    val map1 = mutableMapOf("a" to 1, "b" to 2)
    val map2 = mapOf("b" to 3, "c" to 4)
    // 循环map2, 从map1中获取同key的值, 然后加起来, 放入map1中
    map2.forEach { (key, value) ->
    	// oldVal 和 newVal 分别对应于 map1 和 map2 中的值
        map1.merge(key, value) { oldValue, newValue -> oldValue + newValue }
    }
    // {a=1, b=5, c=4}
    println(map1)
}    

函数

1.检查函数

在 Kotlin 里，检查函数的作用是对特定条件进行验证，当条件不满足时就会抛出异常。

1.1.require函数

require函数的用途是检查传入函数的参数是否满足特定条件。要是条件不成立，它就会抛出IllegalArgumentException异常。

• 验证函数参数是否合法
• 异常：IllegalArgumentException
• 场景：函数入口参数校验

fun connect(url: String) {
    require(url.startsWith("https")) { "URL 必须使用 HTTPS 协议" }
    // 连接逻辑...
}
fun divide(a: Int, b: Int): Int {
    require(b != 0) { "除数不能为零" }
    return a / b
}

1.2.check函数

check函数主要用于检查函数内部的状态是否满足特定条件。若条件不成立，它会抛出IllegalStateException异常。

• 作用：验证对象或程序状态是否合法
• 异常：IllegalStateException
• 场景：对象状态/业务流程校验

fun withdraw(amount: Double) {
    check(amount <= balance) { "余额不足，当前余额：$balance" }
    balance -= amount
}

1.3.error函数

error函数的作用是在遇到不合法的状态时直接抛出IllegalStateException异常。

• 作用：立即终止程序并抛出异常
• 场景：不可恢复的错误情况

fun getConfig(key: String): String {
    return configs[key] ?: error("关键配置 $key 缺失")
}

1.4.requireNotNull() / checkNotNull() - 空安全函数

requireNotNull() / checkNotNull()函数的作用是在遇到null状态时直接抛出IllegalArgumentException异常。

• 作用：替代 !! 的非空校验
• 额外收益：返回非空类型（Smart Cast）

fun process(data: String?) {
    val validData = requireNotNull(data) { "数据不能为 null" }
    // 后续 validData 自动转为非空 String
}