Comparador en Kotlin

En contextos de programación, a medida que surge la necesidad de un nuevo tipo, también hay una tarea importante de ordenar las instancias de un tipo. Para comparar dos instancias de un tipo, implementamos Comparable interface . Sin embargo, dado que las instancias de pedido deben compararse automáticamente y también dado que el orden puede variar según varios parámetros, Kotlin proporciona una interfaz Comparator simple . Esta interfaz compara dos objetos de un tipo y los organiza en un orden.

Función –

compare: esta función compara dos instancias de un tipo y devuelve cero si ambas son iguales, un número negativo si la segunda instancia es más grande; de ​​lo contrario, devuelve un número positivo.

abstract fun compare(a: T, b: T): Int

Funciones de extensión –

invertido: esta función toma un comparador como argumento y devuelve el comparador con el orden inverso al del comparador pasado.

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

 
luego: Esta función combina dos comparadores, y el segundo se usa solo cuando los valores son iguales según el primer comparador.

infix fun <T> Comparator<T>.then(
    comparator: Comparator<in T>
): Comparator<T>

Ejemplo para demostrar las funciones comparar, luego e inversa.

// A simple class to represent a name
class Name(val firstName: String,val lastName: String){
    override fun toString(): String {
        return """$firstName $lastName"""
    }
}
   
// A comparator to compare first names of Name
class ComparatorOne: Comparator<Name>{
    override fun compare(o1: Name?, o2: Name?): Int {
        if(o1 == null || o2 == null){
            return 0;
        }
        return o1.firstName.compareTo(o2.firstName)
    }
}
   
// A comparator to compare last names of Name
class AnotherComparator: Comparator<Name>{
    override fun compare(o1: Name?, o2: Name?): Int {
        if(o1 == null || o2 == null)
            return 0
        return o1.lastName.compareTo(o2.lastName)
    }
}
   
fun main(){
    val list = ArrayList<Name>()
    list.add(Name("Steve","Waugh"))
    list.add(Name("Steve","Smith"))
    list.add(Name("Virat","Kohli"))
    list.add(Name("Kane","Williamson"))
    list.add(Name("Joe","Root"))
   
    println("The list is:")
    println(list)
   
    val comparatorOne = ComparatorOne()
    // Sorting list according to first names
    list.sortWith(comparatorOne)
    println("List sorted according to first name")
    println(list)
   
    val anotherComparator = AnotherComparator()
    val finalComparator = comparatorOne.then(anotherComparator)
    // Sorting list according to first name then by last name
    list.sortWith(finalComparator)
    println("List sorted according to first name and last name")
    println(list)
   
    val reverseComparator = finalComparator.reversed()
    // Reverse sorting the list
    list.sortWith(reverseComparator)
    println("List reverse sorted")
    println(list)
}

Producción:

The list is:
[Steve Waugh, Steve Smith, Virat Kohli, Kane Williamson, Joe Root]
List sorted according to first name
[Joe Root, Kane Williamson, Steve Waugh, Steve Smith, Virat Kohli]
List sorted according to first name and last name
[Joe Root, Kane Williamson, Steve Smith, Steve Waugh, Virat Kohli]
List reverse sorted
[Virat Kohli, Steve Waugh, Steve Smith, Kane Williamson, Joe Root]

thenBy: esta función convierte las instancias de tipo en una instancia de tipo Comparable y luego las compara usando estas instancias.

fun <T> Comparator<T>.thenBy(
    selector: (T) -> Comparable<*>?
): Comparator<T>

 
thenByDescending: esta función devuelve un comparador descendente que convierte un valor en una instancia de tipo Comparable y luego compara las instancias.

inline fun <T> Comparator<T>.thenByDescending(
    crossinline selector: (T) -> Comparable<*>?
): Comparator<T>

Ejemplo para demostrar las funciones thenBy y thenByDescending

class Person(val height: Int,val weight: Int){
    override fun toString(): String {
        return "Height = ${height}, Weight = ${weight}"
    }
}
   
fun main() {
    val comparator = compareBy<Person> { it.height }
    val list = listOf<Person>(
        Person(4, 10),
        Person(2, 10),
        Person(3, 45),
        Person(3, 25),
        Person(7, 95),
        Person(5, 50)
    )
   
    println("Sorted first according to height then by weight")
    val anotherComparator = comparator.thenBy { it.weight }
    println(list.sortedWith(anotherComparator))
   
    println("Sorted first according to weight then by descending order in height")
    val comparator2 = compareBy<Person> { it.weight }.thenByDescending { it.height }
    println(list.sortedWith(comparator2))
}

Producción:

Sorted first according to height then by weight
[Height = 2, Weight = 10, Height = 3, Weight = 25, Height = 3, Weight = 45, Height = 4, Weight = 10, Height = 5, Weight = 50, Height = 7, Weight = 95]
Sorted first according to weight then by descending order in height
[Height = 4, Weight = 10, Height = 2, Weight = 10, Height = 3, Weight = 25, Height = 3, Weight = 45, Height = 5, Weight = 50, Height = 7, Weight = 95]

 
thenComparator: esta función devuelve un comparador que utiliza el comparador principal junto con una función para realizar una comparación.

fun <T> Comparator<T>.thenComparator(
    comparison: (a: T, b: T) -> Int
): Comparator<T>

 
thenDescending: esta función combina dos comparadores, y el segundo se usa solo cuando los valores son iguales según el primer comparador, y ordena los elementos en orden descendente.

infix fun <T> Comparator<T>.thenDescending(
    comparator: Comparator<in T>
): Comparator<T>

Ejemplo para demostrar las funciones thenComparator y thenDescending.

fun main(){
    val list = listOf<Pair<String,Int>>(
        Pair("A",3),
        Pair("B",1),
        Pair("G",345),
        Pair("E",20),
        Pair("A",0),
        Pair("J",0)
    )
   
    val comparator = compareBy<Pair<String,Int>> { it.first }
        .thenComparator({a,b -> compareValues(a.second,b.second)})
   
    println("Pairs sorted by String then by Integers")
    println(list.sortedWith(comparator))
   
    val anotherComparator = compareBy<Pair<String,Int>> { it.second }
    val anotherComparator2 = compareBy<Pair<String,Int>>{it.first}
    println("Pairs sorted by Integers then by Strings in Descending order")
    println(list.sortedWith(anotherComparator.thenDescending(anotherComparator2)))
}

Producción:

Pairs sorted by String then by Integers
[(A, 0), (A, 3), (B, 1), (E, 20), (G, 345), (J, 0)]
Pairs sorted by Integers then by Strings in Descending order
[(J, 0), (A, 0), (B, 1), (A, 3), (E, 20), (G, 345)]