Pedidos de colecciones de Kotlin

Hay ciertas colecciones donde el orden de los elementos es importante. Si toma listas, dos listas nunca son iguales si están ordenadas de manera diferente a pesar de tener los mismos elementos. En Kotlin, hay diferentes formas de ordenar los elementos. 
La mayoría de los tipos integrados son comparables: 
-Los tipos numéricos siguen el orden numérico: 1 es mayor que 0; -2.8f es mayor que -6f, y así sucesivamente. 
-Char y String utilizan el orden lexicográfico: p es mayor que a; el cielo es más grande que el aire. 
Para el tipo definido por el usuario, hay diferentes tipos de órdenes definidas en Kotlin. Se pueden describir de la siguiente manera:
 

Orden natural

Se define para todos aquellos tipos que se heredan de la interfaz Comparable . Para definir este orden para cualquier tipo, debe hacerse heredero de Comparable . Esto se puede hacer usando la función compareTo() que toma otro elemento del mismo tipo y devuelve qué es mayor en forma de valor entero. Con base en estos valores enteros podemos determinar qué objeto es mayor. 
-El valor positivo indica que el objeto del receptor es mayor 
-El valor negativo muestra el argumento del receptor < 
-Cero implica que ambos objetos son iguales. 
A continuación se muestra una clase que se puede usar para pedir artículos que consisten en una parte grande y otra pequeña.
 

class Items(val big: Int, val small: Int): Comparable {
    override fun compareTo(other: Items): Int {
        if (this.big != other.big) {
            return this.big - other.big
        } else if (this.small != other.small) {
            return this.small - other.small
        } else return 0
    }
}
?fun main() {   
    println(Items(1, 2) > Items(1, 3))
    println(Items(2, 0) > Items(1, 5))
}

Las funciones básicas son sorted() y sortedDescending() . Dan el resultado en forma de colección de objetos ordenados en orden Ascendente y Descendente. Estos pueden aplicarse a colecciones de eventos comparables
 

Pedidos personalizados

Le permiten ordenar instancias en cualquier tipo que desee. Esto es especialmente útil para definir el orden de objetos que generalmente no son comparables. 
Para crear un pedido personalizado, creamos un Comparator que contiene la función compare() . Toma dos instancias y las compara dando un valor entero como salida. Este resultado también es similar al método anterior.
 

val lengthComparator = Comparator { str1: String,
                       str2: String -> str1.length - str2.length }
println(listOf("aaa", "bb", "c").sortedWith(lengthComparator))

Aquí usamos la longitud para comparar en lugar del orden lexicográfico prescrito. 
El comparador también se puede definir usando compareBy() de la biblioteca estándar. Esta función toma una función lambda que produce un valor que se usa para comparar y definir el orden personalizado como el orden natural de los valores producidos. 
Usando comparar por( ),
 

println(listOf("aaa", "bb", "c").sortedWith(compareBy { it.length }))

Las funciones básicas son sortedBy() y sortedByDescending() . Asignan los elementos de la colección a valores comparables mediante una función de selección definida y clasifican la colección en el orden natural de los valores.
 

val numbers = listOf("one", "two", "three", "four")
val sortedNumbers = numbers.sortedBy { it.length }
println("Sorted by length ascending: $sortedNumbers")
val sortedByLast = numbers.sortedByDescending { it.last() }
println("Sorted by the last letter descending: $sortedByLast")

Usando sortedWith() , esto se puede escribir como: 
 

val numbers = listOf("one", "two", "three", "four")
println("Sorted by length ascending: ${numbers.sortedWith(compareBy { it.length }

Orden aleatorio

La función que da una nueva Lista que contiene los elementos de la colección en un orden aleatorio usando shuffled() . No se requieren argumentos o con un objeto aleatorio.
 

val numbers = listOf("one", "two", "three", "four")
println(numbers.shuffled())

Orden inverso

Los elementos se pueden invertir usando reversed() . Devuelve una nueva colección donde se da el reverso del original. El original no se cambiará ya que este resultado es básicamente una copia. Otra versión es asReversed() que proporciona una vista invertida en lugar de una copia y, por lo tanto, es liviana. 
 

val numbers = listOf("one", "two", "three", "four")
println(numbers.reversed())
val numbers = listOf("one", "two", "three", "four")
val reversedNumbers = numbers.asReversed()
println(reversedNumbers)