Сортировка коллекций

Порядок элементов является важным аспектом определенных типов коллекций. Например, два списка с одинаковыми элементами не равны, если их элементы упорядочены по-разному.

В Kotlin порядок объектов можно определить несколькими способами.

Во-первых, существует естественный порядок. Он определяется для наследников интерфейса Comparable. Естественный порядок используется для их сортировки, когда другой порядок не указан.

Большинство встроенных типов сравнимы:

• Числовые типы используют традиционный числовой порядок: 1 больше, чем 0; -3.4f больше, чем -5f, и так далее.
• Char и String используют лексикографический порядок: b больше, чем a; world больше, чем hello.

Для определения естественного порядка для пользовательского типа сделайте этот тип наследником Comparable. Это требует реализации функции compareTo(). compareTo() должна принимать другой объект того же типа в качестве аргумента и возвращать целое число, показывающее, какой объект больше:

• Положительные значения показывают, что объект-получатель больше.
• Отрицательные значения показывают, что он меньше аргумента.
• Ноль показывает, что объекты равны.

Ниже приведен класс, который можно использовать для упорядочивания версий, состоящих из основной и дополнительной части.

class Version(val major: Int, val minor: Int): Comparable<Version> {
    override fun compareTo(other: Version): Int {
        if (this.major != other.major) {
            return this.major - other.major
        } else if (this.minor != other.minor) {
            return this.minor - other.minor
        } else return 0
    }
}

fun main() {    
    println(Version(1, 2) > Version(1, 3))
    println(Version(2, 0) > Version(1, 5))
}

Пользовательские порядки позволяют сортировать экземпляры любого типа так, как вам нужно. В частности, вы можете определить порядок для несравнимых объектов или определить порядок, отличный от естественного, для сравнимого типа. Для определения пользовательского порядка для типа создайте для него Comparator. Comparator содержит функцию compare(): она принимает два экземпляра класса и возвращает целое число, являющееся результатом сравнения между ними. Результат интерпретируется таким же образом, как результат compareTo(), как описано выше.

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

Имея lengthComparator, вы можете упорядочить строки по их длине вместо лексикографического порядка по умолчанию.

Более краткий способ определения Comparator — функция compareBy() из стандартной библиотеки. compareBy() принимает лямбда-функцию, которая создает значение Comparable из экземпляра, и определяет пользовательский порядок как естественный порядок созданных значений. С помощью compareBy(), компаратор длин из примера выше выглядит следующим образом:

fun main() {
//sampleStart    
    println(listOf("aaa", "bb", "c").sortedWith(compareBy { it.length }))
//sampleEnd
}

Пакет коллекций Kotlin предоставляет функции для сортировки коллекций в естественном, пользовательском и даже случайном порядке. На этой странице мы опишем функции сортировки, которые применяются к только для чтения коллекциям. Эти функции возвращают свой результат в виде новой коллекции, содержащей элементы исходной коллекции в запрошенном порядке. Чтобы узнать о функциях для сортировки изменяемых коллекций на месте, см. Список специфических операций.

Естественный порядок

Основные функции sorted() и sortedDescending() возвращают элементы коллекции, отсортированные по возрастающей и убывающей последовательности в соответствии с их естественным порядком. Эти функции применяются к коллекциям элементов Comparable.

fun main() {
//sampleStart
    val numbers = listOf("one", "two", "three", "four")

    println("Sorted ascending: ${numbers.sorted()}")
    println("Sorted descending: ${numbers.sortedDescending()}")
//sampleEnd
}

Пользовательские порядки

Для сортировки в пользовательских порядках или сортировки несравнимых объектов существуют функции sortedBy() и sortedByDescending(). Они принимают функцию селектора, которая отображает элементы коллекции в значения Comparable, и сортируют коллекцию в естественном порядке этих значений.

fun main() {
//sampleStart
    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")
//sampleEnd
}

Для определения пользовательского порядка сортировки коллекции вы можете предоставить собственный Comparator. Для этого вызовите функцию sortedWith(), передав в неё ваш Comparator. С помощью этой функции сортировка строк по их длине выглядит следующим образом:

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

Обратный порядок

Вы можете получить коллекцию в обратном порядке, используя функцию reversed().

fun main() {
//sampleStart
    val numbers = listOf("one", "two", "three", "four")
    println(numbers.reversed())
//sampleEnd
}

reversed() возвращает новую коллекцию с копиями элементов. Таким образом, если вы измените исходную коллекцию позже, это не повлияет на ранее полученные результаты reversed().

Другая функция обратного порядка - asReversed() - возвращает обратный вид того же экземпляра коллекции, поэтому она может быть более лёгкой и предпочтительнее, чем reversed(), если исходный список не будет меняться.

fun main() {
//sampleStart
    val numbers = listOf("one", "two", "three", "four")
    val reversedNumbers = numbers.asReversed()
    println(reversedNumbers)
//sampleEnd
}

Если исходный список изменяем, все его изменения отражаются в его обратных представлениях и наоборот.

fun main() {
//sampleStart
    val numbers = mutableListOf("one", "two", "three", "four")
    val reversedNumbers = numbers.asReversed()
    println(reversedNumbers)
    numbers.add("five")
    println(reversedNumbers)
//sampleEnd
}

Однако, если изменчивость списка неизвестна или источник вообще не является списком, reversed() более предпочтительна, поскольку ее результат является копией, которая не будет изменяться в будущем.

Случайный порядок

Наконец, существует функция, которая возвращает новую List, содержащую элементы коллекции в случайном порядке - shuffled(). Вы можете вызвать её без аргументов или с объектом Random.

fun main() {
//sampleStart
     val numbers = listOf("one", "two", "three", "four")
     println(numbers.shuffled())
//sampleEnd
}