Kotlin比较接口

在 Kotlin 中，Comparable 和 Comparator 是两个允许开发者对相同或不同类的对象进行比较的接口。这两个接口通常用于基于一个或多个属性对对象集合进行排序与排序操作。本文将概述 Kotlin 的 Comparable 和 Comparator 接口，解释它们的用法，并对它们之间的区别进行说明。

Kotlin 的 Comparable 接口

Comparable 接口用于定义对象的自然顺序。当一个类实现 Comparable 接口时，必须重写 compareTo() 方法：

public operator fun compareTo(other: T): Int

该方法接收一个相同类型的对象作为参数，返回一个整数值：

• 如果当前对象小于参数对象，返回负数（通常为 -1）；

• 如果当前对象等于参数对象，返回 0；

• 如果当前对象大于参数对象，返回正数（通常为 1）。

示例代码：

data class Person(val name: String, val age: Int): Comparable<Person> {
  override fun compareTo(other: Person): Int {
    return this.age - other.age
  }
}

解释：在这段代码中，Person 类实现了 Comparable 接口，并重写了 compareTo() 方法。该方法按年龄比较 Person 对象：

• 如果当前对象的 age 小于另一个人的 age，则返回负数；

• 如果大于，则返回正数；

• 如果相等，返回 0。

因此，我们可以这样对 Person 对象列表按年龄排序：

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

解释：sorted() 函数使用 compareTo() 方法定义的自然顺序对列表进行排序。

与 Comparable 相关的扩展函数

coerceAtLeast()
如果当前对象小于指定的最小值，则返回最小值；否则返回当前对象。

fun <T : Comparable<T>> T.coerceAtLeast(minimumValue: T): T

示例：

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

    val minimum = Person("Jack", 28)
    println(people[0].age.coerceAtLeast(minimum.age)) // 28
    println(people[1].age.coerceAtLeast(minimum.age)) // 30
}

coerceAtMost()
如果当前对象大于指定的最大值，则返回最大值；否则返回当前对象。

fun <T : Comparable<T>> T.coerceAtMost(maximumValue: T): T

示例：

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

    val maximum = Person("Jack", 28)
    println(people[0].age.coerceAtMost(maximum.age)) // 25
    println(people[1].age.coerceAtMost(maximum.age)) // 28
}

coerceIn()
检查当前对象是否在最小值和最大值之间，若小于最小值返回最小值，若大于最大值返回最大值，否则返回自身。

fun <T : Comparable<T>> T.coerceIn(minimumValue: T?, maximumValue: T?): T

示例：

fun main() {
    println(25.coerceIn(18..28)) // 25
    println(15.coerceIn(18..28)) // 18
    println(30.coerceIn(18..28)) // 28
}

Kotlin 的 Comparator 接口

Comparator 接口用于定义对象的自定义顺序。当一个类实现 Comparator 接口时，必须重写 compare() 方法：

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

class PersonAgeComparator : Comparator<Person> {
    override fun compare(p1: Person, p2: Person): Int {
        return p1.age - p2.age
    }
}

解释：PersonAgeComparator 类实现了 Comparator<Person> 接口，并重写了 compare() 方法。该方法比较两个 Person 对象的年龄：

• 若 p1.age < p2.age，返回负数；

• 若 p1.age > p2.age，返回正数；

• 若两者相等，返回 0。

使用 Comparator 实例：

fun main() {
    val ageComparator = Comparator<Person> { p1, p2 -> p1.age - p2.age }

    val people = listOf(
        Person("Alice", 25), Person("Bob", 30), Person("Charlie", 20)
    )
    val sortedPeople = people.sortedWith(ageComparator)
    println(sortedPeople)
}

输出：

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

与 Comparator 相关的方法

reversed()
反转当前比较器的顺序。

fun <T> Comparator<T>.reversed(): Comparator<T>

示例：

fun main() {
    val ageComparator = Comparator<Person> { p1, p2 -> p1.age - p2.age }.reversed()

    val people = listOf(
        Person("Alice", 25), Person("Bob", 30), Person("Charlie", 20)
    )
    val sortedPeople = people.sortedWith(ageComparator)
    println(sortedPeople)
}

输出：

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

Comparable 与 Comparator 的区别

总结

Comparable 和 Comparator 是非常强大的接口，可用于对对象集合进行排序。当需要对同一类的对象进行默认排序时，实现 Comparable；当需要自定义排序或对不同类对象排序时，实现 Comparator。Kotlin 标准库提供了许多接受 Comparator 的函数，使排序变得简单而高效。