Kotlin代码优化

目录

一、空安全与类型处理

[1. 用 ?. 替代显式 null 判断](#1. 用 ?. 替代显式 null 判断)

[2. 用 ?: 提供默认值，替代 if-else](#2. 用 ?: 提供默认值，替代 if-else)

[3. 用 ?.let 替代 if-not-null 代码块](#3. 用 ?.let 替代 if-not-null 代码块)

[4. 用 takeIf / takeUnless 替代条件过滤](#4. 用 takeIf / takeUnless 替代条件过滤)

[5. 用 as? 安全类型转换替代 try-catch](#5. 用 as? 安全类型转换替代 try-catch)

[6. 用 requireNotNull / checkNotNull 提前抛出异常](#6. 用 requireNotNull / checkNotNull 提前抛出异常)

[7. 用 !! 的替代方案：明确处理或提前返回](#7. 用 !! 的替代方案：明确处理或提前返回)

[8. 用 orEmpty() 处理可能为 null 的集合/字符串](#8. 用 orEmpty() 处理可能为 null 的集合/字符串)

二、作用域函数精准选用

[9. 配置对象用 apply，返回自身](#9. 配置对象用 apply，返回自身)

[10. 计算并返回结果用 run](#10. 计算并返回结果用 run)

[11. 链式调用中插入副作用用 also](#11. 链式调用中插入副作用用 also)

[12. 上下文对象上调用多个方法用 with](#12. 上下文对象上调用多个方法用 with)

[13. 非空且需转换时用 let](#13. 非空且需转换时用 let)

[14. 避免 run / let / also 嵌套过深](#14. 避免 run / let / also 嵌套过深)

[15. takeIf + let 组合过滤](#15. takeIf + let 组合过滤)

[16. 用 repeat 替代 for 循环计数](#16. 用 repeat 替代 for 循环计数)

三、集合与函数式操作

[17. 用 mapNotNull 替代 map + filterNotNull](#17. 用 mapNotNull 替代 map + filterNotNull)

[18. 用 groupBy / associateBy 替代手动分组](#18. 用 groupBy / associateBy 替代手动分组)

[19. 用 associate / associateWith 构建 Map](#19. 用 associate / associateWith 构建 Map)

[20. 用 partition 替代两次 filter](#20. 用 partition 替代两次 filter)

[21. 用 any / none / all 替代 count/size 判断](#21. 用 any / none / all 替代 count/size 判断)

[22. 用 firstOrNull / find 替代 get(0) + try-catch](#22. 用 firstOrNull / find 替代 get(0) + try-catch)

[23. 用 distinctBy 去重](#23. 用 distinctBy 去重)

[24. 用 zip 合并两个列表](#24. 用 zip 合并两个列表)

[25. 用 flatten / flatMap 处理嵌套集合](#25. 用 flatten / flatMap 处理嵌套集合)

[26. 用 sortedBy / sortedWith 替代 Collections.sort](#26. 用 sortedBy / sortedWith 替代 Collections.sort)

[27. 用 buildList / buildString / buildMap 替代临时可变集合](#27. 用 buildList / buildString / buildMap 替代临时可变集合)

[28. 用 ifEmpty / ifBlank 提供兜底](#28. 用 ifEmpty / ifBlank 提供兜底)

四、函数与表达式简化

[29. 用单行表达式函数替代代码块](#29. 用单行表达式函数替代代码块)

[30. 用默认参数替代重载函数](#30. 用默认参数替代重载函数)

[31. 用命名参数提高可读性](#31. 用命名参数提高可读性)

[32. 用 when 替代冗长的 if-else if](#32. 用 when 替代冗长的 if-else if)

[33. when 作为表达式直接返回](#33. when 作为表达式直接返回)

[34. 用 require / check 替代前置条件判断](#34. 用 require / check 替代前置条件判断)

[35. 用 try-with-resources 的 Kotlin 版：use](#35. 用 try-with-resources 的 Kotlin 版：use)

[36. 用 useLines / bufferedReader 处理文件](#36. 用 useLines / bufferedReader 处理文件)

[37. 用 TODO() 标记未实现](#37. 用 TODO() 标记未实现)

[38. 用 inline + reified 替代反射获取泛型](#38. 用 inline + reified 替代反射获取泛型)

五、类与对象设计

[39. 用 data class 替代 POJO](#39. 用 data class 替代 POJO)

[40. 用 copy() 创建变体对象（不可变优先）](#40. 用 copy() 创建变体对象（不可变优先）)

[41. 用 sealed class / sealed interface 替代枚举+继承](#41. 用 sealed class / sealed interface 替代枚举+继承)

[42. 用 object 单例替代手动单例模式](#42. 用 object 单例替代手动单例模式)

[43. 用 companion object 替代 static 工具类](#43. 用 companion object 替代 static 工具类)

[44. 用扩展函数替代工具类](#44. 用扩展函数替代工具类)

[45. 用属性委托 by lazy 替代手动懒加载](#45. 用属性委托 by lazy 替代手动懒加载)

[46. 用 by Delegates.observable 监听属性变化](#46. 用 by Delegates.observable 监听属性变化)

六、字符串与格式化

[47. 用字符串模板替代拼接](#47. 用字符串模板替代拼接)

[48. 用多行字符串 """ 替代转义换行](#48. 用多行字符串 """ 替代转义换行)

[49. 用 replaceIndent / trimMargin 处理缩进](#49. 用 replaceIndent / trimMargin 处理缩进)

[50. 用 padStart / padEnd 替代手动补零](#50. 用 padStart / padEnd 替代手动补零)

[51. 用 removePrefix / removeSuffix / removeSurrounding](#51. 用 removePrefix / removeSuffix / removeSurrounding)

[52. 用 chunked 分割字符串/列表](#52. 用 chunked 分割字符串/列表)

七、协程与异步

[53. 用 suspend 函数替代回调地狱](#53. 用 suspend 函数替代回调地狱)

[54. 用 flow { } 替代回调式数据流](#54. 用 flow { } 替代回调式数据流)

[55. 用 withContext(Dispatchers.IO) 切换线程，不要自行创建线程](#55. 用 withContext(Dispatchers.IO) 切换线程，不要自行创建线程)

[56. 用 async/await 并行执行独立任务](#56. 用 async/await 并行执行独立任务)

[57. 用 supervisorScope 隔离子协程失败](#57. 用 supervisorScope 隔离子协程失败)

[58. 用 Flow.combine / zip 合并多个流](#58. 用 Flow.combine / zip 合并多个流)

八、性能与内存

[59. 用 ArrayDeque 替代 LinkedList](#59. 用 ArrayDeque 替代 LinkedList)

[60. 用 Sequence 替代 List 处理大数据链式操作](#60. 用 Sequence 替代 List 处理大数据链式操作)

[61. 用 const val 替代普通 val 编译期常量](#61. 用 const val 替代普通 val 编译期常量)

[62. 用 inline 函数减少高阶函数 lambda 开销](#62. 用 inline 函数减少高阶函数 lambda 开销)

[63. 用 Array 替代 List 存储基础类型](#63. 用 Array 替代 List 存储基础类型)

[64. 用 measureTimeMillis / measureTimedValue 计时](#64. 用 measureTimeMillis / measureTimedValue 计时)

九、可读性与惯用法

[65. 用 isBlank / isNotBlank 替代 trim + isEmpty](#65. 用 isBlank / isNotBlank 替代 trim + isEmpty)

[66. 用 to 创建 Pair（中缀函数）](#66. 用 to 创建 Pair（中缀函数）)

[67. 用 until 替代 ..-1](#67. 用 until 替代 ..-1)

[68. 用 indices / withIndex 遍历索引+元素](#68. 用 indices / withIndex 遍历索引+元素)

[69. 用 check / error 处理不可能状态](#69. 用 check / error 处理不可能状态)

[70. 用 compareValuesBy 替代手动 Comparator](#70. 用 compareValuesBy 替代手动 Comparator)

[71. 用 random() / shuffled() 替代 Random 手动取](#71. 用 random() / shuffled() 替代 Random 手动取)

[72. 用 coerceIn / coerceAtLeast / coerceAtMost 限制范围](#72. 用 coerceIn / coerceAtLeast / coerceAtMost 限制范围)

十、Android/业务场景专项

[73. 用 viewBinding 替代 findViewById](#73. 用 viewBinding 替代 findViewById)

[74. 用 doOnNextLayout / post 替代 Handler 延迟](#74. 用 doOnNextLayout / post 替代 Handler 延迟)

[75. 用 resources.getIdentifier 的替代：类型安全引用](#75. 用 resources.getIdentifier 的替代：类型安全引用)

[76. 用 SparseArray / LongSparseArray 替代 HashMap](#76. 用 SparseArray / LongSparseArray 替代 HashMap)

[77. 用 viewModelScope / lifecycleScope 替代手动协程管理](#77. 用 viewModelScope / lifecycleScope 替代手动协程管理)

[78. 用 Result 类型或密封类替代异常控制流](#78. 用 Result 类型或密封类替代异常控制流)

[79. 用 SharedPreferences 的 edit {} 扩展（KTX）](#79. 用 SharedPreferences 的 edit {} 扩展（KTX）)

[80. 用 bundleOf / intentOf 等 KTX 构建参数](#80. 用 bundleOf / intentOf 等 KTX 构建参数)

---

一、空安全与类型处理

1. 用 ?. 替代显式 null 判断

// 优化前
if (user != null) {
    println(user.name)
}

// 优化后
println(user?.name)

2. 用 ?: 提供默认值，替代 if-else

// 优化前
val name = if (user != null) user.name else "Unknown"

// 优化后
val name = user?.name ?: "Unknown"

3. 用 ?.let 替代 if-not-null 代码块

// 优化前
if (file != null) {
    processFile(file)
}

// 优化后
file?.let { processFile(it) }

4. 用 takeIf / takeUnless 替代条件过滤

// 优化前
val validNumber = if (number > 0) number else null

// 优化后
val validNumber = number.takeIf { it > 0 }

5. 用 as? 安全类型转换替代 try-catch

// 优化前
try {
    val list = obj as List<*>
} catch (e: ClassCastException) { ... }

// 优化后
(obj as? List<*>)?.let { ... }

6. 用 requireNotNull / checkNotNull 提前抛出异常

// 优化前
if (config == null) throw IllegalArgumentException("Config required")

// 优化后
val safeConfig = requireNotNull(config) { "Config required" }

7. 用 !! 的替代方案：明确处理或提前返回

// 优化前（危险）
val name = user!!.name

// 优化后（安全）
val name = user?.name ?: return

8. 用 orEmpty() 处理可能为 null 的集合/字符串

// 优化前
val list = if (items != null) items else emptyList()

// 优化后
val list = items.orEmpty()

---

二、作用域函数精准选用

9. 配置对象用 apply，返回自身

// 优化前
val paint = Paint()
paint.color = Color.RED
paint.strokeWidth = 5f

// 优化后
val paint = Paint().apply {
    color = Color.RED
    strokeWidth = 5f
}

10. 计算并返回结果用 run

// 优化前
val result: Int
if (list != null) {
    result = list.size * 2
}

// 优化后
val result = list?.run { size * 2 }

11. 链式调用中插入副作用用 also

// 优化前
val file = createTempFile()
log.info("Created: $file")

// 优化后
val file = createTempFile().also { log.info("Created: $it") }

12. 上下文对象上调用多个方法用 with

// 优化前
canvas.drawCircle(...)
canvas.drawRect(...)
canvas.drawText(...)

// 优化后
with(canvas) {
    drawCircle(...)
    drawRect(...)
    drawText(...)
}

13. 非空且需转换时用 let

// 优化前
val length = if (str != null) str.length else 0

// 优化后
val length = str?.let { it.length } ?: 0

14. 避免 run / let / also 嵌套过深

// 优化前（嵌套地狱）
obj?.let { it.name?.let { name -> name.uppercase() } }

// 优化后（Elvis 提前返回或拆分）
obj?.name?.uppercase() ?: ""

15. takeIf + let 组合过滤

// 优化前
val valid = if (age >= 18) age else null

// 优化后
val valid = age.takeIf { it >= 18 }

16. 用 repeat 替代 for 循环计数

// 优化前
for (i in 0 until 3) { println("Hi") }

// 优化后
repeat(3) { println("Hi") }

---

三、集合与函数式操作

17. 用 mapNotNull 替代 map + filterNotNull

// 优化前
list.map { it.toIntOrNull() }.filterNotNull()

// 优化后
list.mapNotNull { it.toIntOrNull() }

18. 用 groupBy / associateBy 替代手动分组

// 优化前
val map = mutableMapOf<String, MutableList<User>>()
users.forEach { map.getOrPut(it.dept) { mutableListOf() }.add(it) }

// 优化后
val map = users.groupBy { it.dept }

19. 用 associate / associateWith 构建 Map

// 优化前
val map = mutableMapOf<Int, String>()
list.forEach { map[it] = it.toString() }

// 优化后
val map = list.associateWith { it.toString() }

20. 用 partition 替代两次 filter

// 优化前
val passed = list.filter { it.score >= 60 }
val failed = list.filter { it.score < 60 }

// 优化后
val (passed, failed) = list.partition { it.score >= 60 }

21. 用 any / none / all 替代 count/size 判断

// 优化前
if (list.filter { it.isActive }.isNotEmpty()) { ... }

// 优化后
if (list.any { it.isActive }) { ... }

22. 用 firstOrNull / find 替代 get(0) + try-catch

// 优化前
val first = if (list.isNotEmpty()) list[0] else null

// 优化后
val first = list.firstOrNull()

23. 用 distinctBy 去重

// 优化前
val seen = mutableSetOf<String>()
val unique = list.filter { seen.add(it.id) }

// 优化后
val unique = list.distinctBy { it.id }

24. 用 zip 合并两个列表

// 优化前
val pairs = mutableListOf<Pair<A, B>>()
for (i in listA.indices) {
    pairs.add(listA[i] to listB[i])
}

// 优化后
val pairs = listA.zip(listB)

25. 用 flatten / flatMap 处理嵌套集合

// 优化前
val all = mutableListOf<Item>()
lists.forEach { all.addAll(it) }

// 优化后
val all = lists.flatten()

// flatMap 一步到位
val names = departments.flatMap { it.employees }.map { it.name }

26. 用 sortedBy / sortedWith 替代 Collections.sort

// 优化前
Collections.sort(list, Comparator { a, b -> a.age - b.age })

// 优化后
val sorted = list.sortedBy { it.age }

27. 用 buildList / buildString / buildMap 替代临时可变集合

// 优化前
val list = mutableListOf<String>()
list.add("A")
list.add("B")
return list

// 优化后
return buildList {
    add("A")
    add("B")
}

28. 用 ifEmpty / ifBlank 提供兜底

// 优化前
val display = if (name.isEmpty()) "匿名" else name

// 优化后
val display = name.ifEmpty { "匿名" }

---

四、函数与表达式简化

29. 用单行表达式函数替代代码块

// 优化前
fun sum(a: Int, b: Int): Int {
    return a + b
}

// 优化后
fun sum(a: Int, b: Int) = a + b

30. 用默认参数替代重载函数

// 优化前
fun loadData() = loadData(false)
fun loadData(force: Boolean) { ... }

// 优化后
fun loadData(force: Boolean = false) { ... }

31. 用命名参数提高可读性

// 优化前
createUser("Tom", 25, true)

// 优化后
createUser(name = "Tom", age = 25, isVip = true)

32. 用 when 替代冗长的 if-else if

// 优化前
val type = if (code == 1) "A" else if (code == 2) "B" else "C"

// 优化后
val type = when (code) {
    1 -> "A"
    2 -> "B"
    else -> "C"
}

33. when 作为表达式直接返回

// 优化前
fun getColor(type: Int): Int {
    return when (type) {
        1 -> Color.RED
        2 -> Color.BLUE
        else -> Color.GRAY
    }
}

// 优化后（单行）
fun getColor(type: Int) = when (type) {
    1 -> Color.RED
    2 -> Color.BLUE
    else -> Color.GRAY
}

34. 用 require / check 替代前置条件判断

// 优化前
if (age < 0) throw IllegalArgumentException("Invalid age")

// 优化后
require(age >= 0) { "Invalid age" }

35. 用 try-with-resources 的 Kotlin 版：use

// 优化前
val stream = FileInputStream(file)
try {
    stream.read()
} finally {
    stream.close()
}

// 优化后
FileInputStream(file).use { it.read() }

36. 用 useLines / bufferedReader 处理文件

// 优化前
val lines = File("data.txt").readLines()
lines.forEach { ... }

// 优化后（内存友好，大文件不一次性加载）
File("data.txt").useLines { lines ->
    lines.filter { it.isNotBlank() }.forEach { ... }
}

37. 用 TODO() 标记未实现

// 优化前（空实现，容易遗漏）
fun calculate(): Int {
    return 0 // 待实现
}

// 优化后
fun calculate(): Int = TODO("等待算法确认")

38. 用 inline + reified 替代反射获取泛型

// 优化前
val type = object : TypeToken<List<String>>() {}.type

// 优化后
inline fun <reified T> typeOf() = typeOf<T>()

---

五、类与对象设计

39. 用 data class 替代 POJO

// 优化前
class User(val name: String, val age: Int) {
    override fun equals(other: Any?) = ...
    override fun hashCode() = ...
    override fun toString() = ...
}

// 优化后
data class User(val name: String, val age: Int)

40. 用 copy() 创建变体对象（不可变优先）

// 优化前
val newUser = User(old.name, old.age + 1)

// 优化后
val newUser = old.copy(age = old.age + 1)

41. 用 sealed class / sealed interface 替代枚举+继承

// 优化前
interface Result
class Success(val data: String) : Result
class Error(val msg: String) : Result

// 优化后（when 可穷举，无需 else）
sealed interface Result
data class Success(val data: String) : Result
data class Error(val msg: String) : Result

42. 用 object 单例替代手动单例模式

// 优化前
class DatabaseHelper private constructor() { ... }
val instance = DatabaseHelper.getInstance()

// 优化后
object DatabaseHelper { ... }

43. 用 companion object 替代 static 工具类

// 优化前
class StringUtils {
    companion object {
        fun isEmpty(str: String?) = str.isNullOrEmpty()
    }
}

// 或者直接扩展函数（见第44条）

44. 用扩展函数替代工具类

// 优化前
StringUtils.capitalize(name)

// 优化后
fun String.capitalizeFirst() = this.replaceFirstChar { it.uppercase() }
name.capitalizeFirst()

45. 用属性委托 by lazy 替代手动懒加载

// 优化前
private var _adapter: Adapter? = null
fun getAdapter(): Adapter {
    if (_adapter == null) _adapter = Adapter()
    return _adapter!!
}

// 优化后
private val adapter by lazy { Adapter() }

46. 用 by Delegates.observable 监听属性变化

// 优化前
var count = 0
    set(value) {
        field = value
        onCountChanged(value)
    }

// 优化后
var count by Delegates.observable(0) { _, old, new ->
    if (old != new) onCountChanged(new)
}

---

六、字符串与格式化

47. 用字符串模板替代拼接

// 优化前
val msg = "Hello, " + name + "! You have " + count + " messages."

// 优化后
val msg = "Hello, $name! You have $count messages."

48. 用多行字符串 """ 替代转义换行

// 优化前
val json = "{\n  \"name\": \"$name\",\n  \"age\": $age\n}"

// 优化后
val json = """
    {
      "name": "$name",
      "age": $age
    }
""".trimIndent()

49. 用 replaceIndent / trimMargin 处理缩进

val text = """
    |第一行
    |第二行
""".trimMargin("|")

50. 用 padStart / padEnd 替代手动补零

// 优化前
val code = if (num < 10) "0$num" else "$num"

// 优化后
val code = num.toString().padStart(2, '0')

51. 用 removePrefix / removeSuffix / removeSurrounding

// 优化前
val clean = if (str.startsWith("[")) str.substring(1) else str

// 优化后
val clean = str.removePrefix("[")

52. 用 chunked 分割字符串/列表

// 优化前
for (i in 0 until str.length step 3) { ... }

// 优化后
val groups = str.chunked(3) // ["abc", "def", "ghi"]

---

七、协程与异步

53. 用 suspend 函数替代回调地狱

// 优化前
api.fetchUser(id, object : Callback<User> {
    override fun onSuccess(user: User) {
        api.fetchOrders(user.id, object : Callback<List<Order>> {
            override fun onSuccess(orders: List<Order>) { ... }
        })
    }
})

// 优化后
val user = api.fetchUser(id)
val orders = api.fetchOrders(user.id)

54. 用 flow { } 替代回调式数据流

// 优化前
locationManager.requestUpdates(object : LocationListener {
    override fun onLocationChanged(loc: Location) { emit(loc) }
})

// 优化后
fun locationFlow() = callbackFlow {
    val listener = LocationListener { trySend(it) }
    locationManager.requestUpdates(listener)
    awaitClose { locationManager.removeUpdates(listener) }
}

55. 用 withContext(Dispatchers.IO) 切换线程，不要自行创建线程

// 优化前
thread {
    val data = loadFromDisk()
    runOnUiThread { updateUI(data) }
}

// 优化后
lifecycleScope.launch {
    val data = withContext(Dispatchers.IO) { loadFromDisk() }
    updateUI(data)
}

56. 用 async/await 并行执行独立任务

// 优化前（串行）
val user = fetchUser()
val config = fetchConfig()
val result = process(user, config)

// 优化后（并行）
coroutineScope {
    val userDeferred = async { fetchUser() }
    val configDeferred = async { fetchConfig() }
    process(userDeferred.await(), configDeferred.await())
}

57. 用 supervisorScope 隔离子协程失败

// 优化前
scope.launch {
    launch { task1() } // task1 崩溃会导致整个 scope 取消
    launch { task2() }
}

// 优化后
supervisorScope {
    launch { task1() } // task1 崩溃不影响 task2
    launch { task2() }
}

58. 用 Flow.combine / zip 合并多个流

// 优化前
var user: User? = null
var orders: List<Order>? = null
fun check() { if (user != null && orders != null) render(user!!, orders!!) }

// 优化后
combine(userFlow, ordersFlow) { u, o -> u to o }
    .collect { (u, o) -> render(u, o) }

---

八、性能与内存

59. 用 ArrayDeque 替代 LinkedList

// 优化前
val queue = LinkedList<String>()

// 优化后
val queue = ArrayDeque<String>() // 缓存友好，性能更好

60. 用 Sequence 替代 List 处理大数据链式操作

// 优化前（中间产生多个 List）
val result = hugeList.filter { ... }.map { ... }.take(10)

// 优化后（惰性求值，避免中间集合）
val result = hugeList.asSequence().filter { ... }.map { ... }.take(10).toList()

61. 用 const val 替代普通 val 编译期常量

// 优化前
val MAX_COUNT = 100 // 运行时分配

// 优化后
const val MAX_COUNT = 100 // 编译期内联

62. 用 inline 函数减少高阶函数 lambda 开销

// 优化前
fun measure(block: () -> Unit) { val start = System.nanoTime(); block() }

// 优化后
inline fun measure(block: () -> Unit) { ... } // lambda 不会生成对象

63. 用 Array 替代 List 存储基础类型

// 优化前
val ints: List<Int> = listOf(1, 2, 3) // Integer 对象

// 优化后
val ints: IntArray = intArrayOf(1, 2, 3) // 原始类型数组

64. 用 measureTimeMillis / measureTimedValue 计时

// 优化前
val start = System.currentTimeMillis()
doWork()
val cost = System.currentTimeMillis() - start

// 优化后
val cost = measureTimeMillis { doWork() }

---

九、可读性与惯用法

65. 用 isBlank / isNotBlank 替代 trim + isEmpty

// 优化前
if (str.trim().isEmpty()) { ... }

// 优化后
if (str.isBlank()) { ... }

66. 用 to 创建 Pair（中缀函数）

// 优化前
val pair = Pair("key", "value")

// 优化后
val pair = "key" to "value"

67. 用 until 替代 ..-1

// 优化前
for (i in 0..list.size - 1) { ... }

// 优化后
for (i in 0 until list.size) { ... }
// 或
for (i in list.indices) { ... }

68. 用 indices / withIndex 遍历索引+元素

// 优化前
for (i in 0 until list.size) {
    val item = list[i]
    println("$i: $item")
}

// 优化后
for ((i, item) in list.withIndex()) {
    println("$i: $item")
}

69. 用 check / error 处理不可能状态

// 优化前
val item = map[key] ?: throw IllegalStateException("Should never happen")

// 优化后
val item = map[key] ?: error("Should never happen")

70. 用 compareValuesBy 替代手动 Comparator

// 优化前
users.sortedWith(Comparator { a, b ->
    if (a.age != b.age) a.age - b.age else a.name.compareTo(b.name)
})

// 优化后
users.sortedWith(compareBy({ it.age }, { it.name }))

71. 用 random() / shuffled() 替代 Random 手动取

// 优化前
list[Random().nextInt(list.size)]

// 优化后
list.random()
list.shuffled()

72. 用 coerceIn / coerceAtLeast / coerceAtMost 限制范围

// 优化前
val valid = if (value < 0) 0 else if (value > 100) 100 else value

// 优化后
val valid = value.coerceIn(0, 100)

---

十、Android/业务场景专项

73. 用 viewBinding 替代 findViewById

// 优化前
val btn = findViewById<<Button>(R.id.btn)
btn.setOnClickListener { ... }

// 优化后
binding.btn.setOnClickListener { ... }

74. 用 doOnNextLayout / post 替代 Handler 延迟

// 优化前
Handler(Looper.getMainLooper()).post { view.width }

// 优化后
view.doOnNextLayout { it.width }

75. 用 resources.getIdentifier 的替代：类型安全引用

// 优化前
val id = resources.getIdentifier("icon_${type}", "drawable", packageName)

// 优化后（用枚举密封类映射）
enum class IconType(@DrawableRes val resId: Int) { ... }

76. 用 SparseArray / LongSparseArray 替代 HashMap<Int, V>

// 优化前
val map = HashMap<Int, String>()

// 优化后（Android 基础类型 key 更省内存）
val map = SparseArray<String>()

77. 用 viewModelScope / lifecycleScope 替代手动协程管理

// 优化前
val job = scope.launch { ... }
override fun onCleared() { job.cancel() }

// 优化后
viewModelScope.launch { ... } // 自动跟随生命周期

78. 用 Result 类型或密封类替代异常控制流

// 优化前
try {
    parseData(json)
} catch (e: Exception) {
    showError()
}

// 优化后
sealed class ParseResult
fun parseData(json: String): ParseResult = ...
when (val result = parseData(json)) { ... }

79. 用 SharedPreferences 的 edit {} 扩展（KTX）

// 优化前
val editor = prefs.edit()
editor.putString("key", "value")
editor.apply()

// 优化后
prefs.edit { putString("key", "value") }

80. 用 bundleOf / intentOf 等 KTX 构建参数

// 优化前
val bundle = Bundle()
bundle.putString("name", name)
bundle.putInt("age", age)

// 优化后
val bundle = bundleOf("name" to name, "age" to age)