Generics Kotlin中成对的比较器

我可以在Kotlin中编写专用类型的比较器

类比较器（）：kotlin.Comparator

---

但是，如何使用泛型为所有可能扩展Comparable的类型编写comparator呢？

您可以使用帮助函数创建comparator—

compareBy

，

CompareBydescing

，

naturalOrder

，

reverseOrder

例如：

val map = mapOf<Int, String>()
// ... add values to the map
val sortedMap: SortedMap<Int, String> = map.toSortedMap(compareByDescending { it })

val map=mapOf（）
// ... 向地图添加值
val sortedMap:sortedMap=map.toSortedMap（compareByDescending{it}）

对于你的情况：

val comparator = compareBy<Pair<Double, Int>> { it.first }

val comparator=compareBy{it.first}

自定义比较器：

class CustomComparator<T: Comparable<T>> : Comparator<T> {
    override fun compare(o1: T, o2: T): Int {
        return o1.compareTo(o2)
    }
}

fun <T, U> pairComparator(
    firstComparator: Comparator<T>, 
    secondComparator: Comparator<U>
): Comparator<Pair<T, U>> = 
         compareBy(firstComparator) { p: Pair<T, U> -> p.first }
          .thenBy(secondComparator) { p: Pair<T, U> -> p.second }

class CustomComparator:比较器{
覆盖乐趣比较（o1:T，o2:T）：Int{
返回o1。比较到（o2）
}
}

您可以使用帮助函数创建比较器-

compareBy

，

compareByDescending

，

naturalOrder

，

reverseOrder

例如：

val map = mapOf<Int, String>()
// ... add values to the map
val sortedMap: SortedMap<Int, String> = map.toSortedMap(compareByDescending { it })

val map=mapOf（）
// ... 向地图添加值
val sortedMap:sortedMap=map.toSortedMap（compareByDescending{it}）

对于你的情况：

val comparator = compareBy<Pair<Double, Int>> { it.first }

val comparator=compareBy{it.first}

自定义比较器：

class CustomComparator<T: Comparable<T>> : Comparator<T> {
    override fun compare(o1: T, o2: T): Int {
        return o1.compareTo(o2)
    }
}

fun <T, U> pairComparator(
    firstComparator: Comparator<T>, 
    secondComparator: Comparator<U>
): Comparator<Pair<T, U>> = 
         compareBy(firstComparator) { p: Pair<T, U> -> p.first }
          .thenBy(secondComparator) { p: Pair<T, U> -> p.second }

class CustomComparator:比较器{
覆盖乐趣比较（o1:T，o2:T）：Int{
返回o1。比较到（o2）
}
}

您可以使用以下功能将两个比较器组合成一个对比较器，该对比较器将对的第一个值与第一个比较器进行比较，然后将第二个值与第二个比较器进行比较：

class CustomComparator<T: Comparable<T>> : Comparator<T> {
    override fun compare(o1: T, o2: T): Int {
        return o1.compareTo(o2)
    }
}

fun <T, U> pairComparator(
    firstComparator: Comparator<T>, 
    secondComparator: Comparator<U>
): Comparator<Pair<T, U>> = 
         compareBy(firstComparator) { p: Pair<T, U> -> p.first }
          .thenBy(secondComparator) { p: Pair<T, U> -> p.second }

---

请参阅此处的完整代码：

您可以使用以下函数将两个比较器组合成一个对比较器，该对比较器将对的第一个值与第一个比较器进行比较，然后将第二个值与第二个比较器进行比较：

class CustomComparator<T: Comparable<T>> : Comparator<T> {
    override fun compare(o1: T, o2: T): Int {
        return o1.compareTo(o2)
    }
}

fun <T, U> pairComparator(
    firstComparator: Comparator<T>, 
    secondComparator: Comparator<U>
): Comparator<Pair<T, U>> = 
         compareBy(firstComparator) { p: Pair<T, U> -> p.first }
          .thenBy(secondComparator) { p: Pair<T, U> -> p.second }

---

请参阅此处的完整代码：

这很好，但我想要一些可以使用的泛型类的实现，例如，Pair和PairWhy

compareBy

和其他助手函数不适合您？您可以使用它来创建任何对的

比较器

。这很好，但我想要一些泛型类的实现，可以用于Pair和PairWhy

compareBy

和其他辅助函数，它们不适合您？您可以使用它创建任意对的

比较器
。