kotlin sortedBy 多重排序如何实现？

Question

在使用 Kotlin 的 `sortedBy` 进行多重排序时，开发者常遇到如何按多个字段优先级排序的问题。例如，先按姓名升序，再按年龄降序。然而，`sortedBy` 本身仅支持单一表达式，若链式调用多个 `sortedBy`，后续调用会覆盖前一次排序结果，无法实现复合排序。那么，如何正确利用 `sortedBy` 与 `thenBy`（或其可空变体）在 Kotlin 中实现稳定、可读性强的多重排序？这是实际开发中常见的痛点。

Answer 1

1. 问题背景与常见误区

在 Kotlin 开发中，sortedBy 是一个常用的集合排序函数，语法简洁且语义清晰。然而，当开发者需要实现多重排序（multi-level sorting）时，常误以为可以通过链式调用多个 sortedBy 实现优先级排序：

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

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

// ❌ 错误方式：后一个 sortedBy 覆盖前一个
val wrongSort = people.sortedBy { it.name }.sortedBy { it.age }

上述代码的问题在于：每次调用 sortedBy 都会重新对整个列表进行排序，而不会保留上一次的排序结果。最终结果仅按年龄排序，姓名的排序被完全覆盖。

这是典型的“覆盖式排序”陷阱，尤其在处理复杂业务数据（如用户列表、订单记录）时，极易导致逻辑错误。

2. 正确的多重排序机制

Kotlin 提供了专为多重排序设计的 API：sortedWith 结合 compareBy，以及更现代的扩展函数 thenBy 和 thenByDescending。

从 Kotlin 1.4 起，sortedBy 返回的是 Comparator 的构建器上下文，允许通过 thenBy 进行链式追加比较条件。

函数名	用途	是否支持可空类型
thenBy	升序追加次级排序字段	否
thenByDescending	降序追加次级排序字段	否
thenByOrNull	支持可空字段的升序排序	是
thenByDescendingOrNull	支持可空字段的降序排序	是

3. 实战示例：复合排序实现

以下是一个完整示例，展示如何使用 sortedWith 与 compareBy 实现先按姓名升序、再按年龄降序的排序逻辑：

val correctSort = people.sortedWith(
    compareBy(Person::name)       // 主排序：姓名升序
        .thenByDescending(Person::age)  // 次排序：年龄降序
)

println(correctSort)
// 输出：
// [Person(name=Alice, age=30), Person(name=Alice, age=20), Person(name=Bob, age=25)]

也可以使用 lambda 表达式形式：

val sortByLambda = people.sortedWith(
    compareBy({ it.name }, { -it.age }) // 利用负号实现年龄降序
)

或者更直观地使用链式 DSL 风格：

val fluentSort = people.sortedWith(
    compareBy { it.name }
        .thenByDescending { it.age }
)

4. 可空字段的安全处理

在实际业务中，对象字段可能为 null（如数据库映射、API 响应），直接使用 thenBy 会导致 NullPointerException。

Kotlin 提供了安全变体：

• thenByOrNull：用于可空字段的升序比较
• thenByDescendingOrNull：用于可空字段的降序比较

data class Employee(val department: String?, val salary: Int?)

val employees = listOf(
    Employee("Engineering", 9000),
    Employee(null, 8000),
    Employee("Engineering", 9500)
)

val safeSort = employees.sortedWith(
    compareBy({ it.department ?: "Unknown" })  // 处理 null 默认值
        .thenByOrNull(Employee::salary)       // 安全比较可空 salary
)

5. 性能与稳定性分析

Kotlin 的 sortedWith 基于 Java 的 Collections.sort()，使用稳定的归并排序算法，时间复杂度为 O(n log n)，且保证相等元素的相对顺序不变。

以下是不同排序方式的性能对比：

排序方式	稳定性	可读性	适用场景
链式 sortedBy	❌ 不稳定（覆盖）	✅ 简单但误导	仅单字段排序
compareBy().thenBy()	✅ 稳定	✅ 高	多字段复合排序
Comparator.thenComparing()	✅ 稳定	🟡 中等	Java 互操作场景
自定义 compareTo	✅ 稳定	❌ 低（冗长）	极复杂逻辑

6. 高阶技巧与 DSL 扩展

对于频繁使用的排序逻辑，可以封装为扩展函数或 DSL 构建器：

fun List<Person>.sortByProfile() = this.sortedWith(
    compareBy(Person::name)
        .thenByDescending(Person::age)
        .thenBy(Person::toString) // 防止歧义，确保总顺序
)

// 使用
val ordered = people.sortByProfile()

此外，结合泛型与作用域函数，可构建通用排序工厂：

inline fun <T> Iterable<T>.sortByMultiple(
    crossinline comparatorBuilder: Comparator.Builder<T>.() -> Unit
): List<T> {
    val builder = Comparator.builder<T>()
    builder.comparatorBuilder()
    return this.sortedWith(builder.build())
}

7. 流程图：多重排序决策路径

graph TD A[开始排序] --> B{是否多字段?} B -- 否 --> C[使用 sortedBy 或 sortedByDescending] B -- 是 --> D{字段是否可空?} D -- 否 --> E[使用 compareBy + thenBy/thenByDescending] D -- 是 --> F[使用 thenByOrNull / thenByDescendingOrNull] E --> G[返回排序结果] F --> G C --> G