sort

Требования к платформе и версии: Common (1.3)


@ExperimentalUnsignedTypes
fun UIntArray.sort()


@ExperimentalUnsignedTypes
fun ULongArray.sort()


@ExperimentalUnsignedTypes
fun UByteArray.sort()


@ExperimentalUnsignedTypes
fun UShortArray.sort()

Сортирует массив на месте.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort()

// after sorting
println(intArray.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}


@ExperimentalUnsignedTypes
fun UIntArray.sort(fromIndex: Int = 0, toIndex: Int = size)


@ExperimentalUnsignedTypes
fun ULongArray.sort(fromIndex: Int = 0, toIndex: Int = size)


@ExperimentalUnsignedTypes
fun UByteArray.sort(fromIndex: Int = 0, toIndex: Int = size)


@ExperimentalUnsignedTypes
fun UShortArray.sort(fromIndex: Int = 0, toIndex: Int = size)

expect fun ByteArray.sort(fromIndex: Int = 0, toIndex: Int = size)

expect fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size)

expect fun IntArray.sort(fromIndex: Int = 0, toIndex: Int = size)

expect fun LongArray.sort(fromIndex: Int = 0, toIndex: Int = size)

expect fun FloatArray.sort(fromIndex: Int = 0, toIndex: Int = size)

expect fun DoubleArray.sort(fromIndex: Int = 0, toIndex: Int = size)

expect fun CharArray.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort(0, 3)

// after sorting
println(intArray.joinToString()) // 2, 3, 4, 1 
   //sampleEnd
}

expect fun IntArray.sort()

expect fun LongArray.sort()

expect fun ByteArray.sort()

expect fun ShortArray.sort()

expect fun DoubleArray.sort()

expect fun FloatArray.sort()

expect fun CharArray.sort()

Сортирует массив на месте.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort()

// after sorting
println(intArray.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}

expect fun <T : Comparable<T>> Array<out T>.sort()

Сортирует массив на месте в соответствии с естественным порядком его элементов.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort()

// after sorting
println(people.joinToString()) // Sweyn Forkbeard, Bjorn Ironside, Ragnar Lodbrok 
   //sampleEnd
}

expect fun <T : Comparable<T>> Array<out T>.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort(0, 2)

// after sorting
println(people.joinToString()) // Bjorn Ironside, Ragnar Lodbrok, Sweyn Forkbeard 
   //sampleEnd
}

expect fun <T : Comparable<T>> MutableList<T>.sort()

Сортирует элементы списка на месте в соответствии с их естественным порядком сортировки.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Примеры

import kotlin.math.*
import kotlin.test.*

fun main() { 
   //sampleStart 
   val mutableList = mutableListOf(4, 3, 2, 1)

// before sorting
println(mutableList.joinToString()) // 4, 3, 2, 1

mutableList.sort()

// after sorting
println(mutableList.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}

Требования к платформе и версии: JS (1.1)

actual fun IntArray.sort()

actual fun LongArray.sort()

actual fun ByteArray.sort()

actual fun ShortArray.sort()

actual fun DoubleArray.sort()

actual fun FloatArray.sort()

actual fun CharArray.sort()

Сортирует массив на месте.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort()

// after sorting
println(intArray.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}

actual fun <T : Comparable<T>> Array<out T>.sort()

Сортирует массив на месте в соответствии с естественным порядком его элементов.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort()

// after sorting
println(people.joinToString()) // Sweyn Forkbeard, Bjorn Ironside, Ragnar Lodbrok 
   //sampleEnd
}

actual fun <T : Comparable<T>> Array<out T>.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort(0, 2)

// after sorting
println(people.joinToString()) // Bjorn Ironside, Ragnar Lodbrok, Sweyn Forkbeard 
   //sampleEnd
}

actual fun ByteArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun IntArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun LongArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun FloatArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun DoubleArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun CharArray.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort(0, 3)

// after sorting
println(intArray.joinToString()) // 2, 3, 4, 1 
   //sampleEnd
}

actual fun <T : Comparable<T>> MutableList<T>.sort()

Сортирует элементы списка на месте в соответствии с их естественным порядком сортировки.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Примеры

import kotlin.math.*
import kotlin.test.*

fun main() { 
   //sampleStart 
   val mutableList = mutableListOf(4, 3, 2, 1)

// before sorting
println(mutableList.joinToString()) // 4, 3, 2, 1

mutableList.sort()

// after sorting
println(mutableList.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}

fun <T> Array<out T>.sort(comparison: (a: T, b: T) -> Int)

Устарело

Предупреждение с версии 1.6

Вместо этого используйте sortWith

Заменить на

this.sortWith(Comparator(comparison))

Сортирует массив на месте в соответствии с порядком, заданным указанной функцией comparison.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

inline fun ByteArray.sort(noinline comparison: (a: Byte, b: Byte) -> Int)

inline fun ShortArray.sort(noinline comparison: (a: Short, b: Short) -> Int)

inline fun IntArray.sort(noinline comparison: (a: Int, b: Int) -> Int)

inline fun LongArray.sort(noinline comparison: (a: Long, b: Long) -> Int)

inline fun FloatArray.sort(noinline comparison: (a: Float, b: Float) -> Int)

inline fun DoubleArray.sort(noinline comparison: (a: Double, b: Double) -> Int)

inline fun CharArray.sort(noinline comparison: (a: Char, b: Char) -> Int)

Устарело

Предупреждение с версии 1.6

Используйте другие функции сортировки из стандартной библиотеки

Сортирует массив на месте в соответствии с порядком, заданным указанной функцией comparison.

Требования к платформе и версии: JVM (1.0)

fun <T> Array<out T>.sort()

Сортирует массив на месте в соответствии с естественным порядком его элементов.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Исключения

ClassCastException

если какой-либо элемент массива не реализует интерфейс Comparable.

fun <T> Array<out T>.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort(0, 2)

// after sorting
println(people.joinToString()) // Bjorn Ironside, Ragnar Lodbrok, Sweyn Forkbeard 
   //sampleEnd
}

actual fun IntArray.sort()

actual fun LongArray.sort()

actual fun ByteArray.sort()

actual fun ShortArray.sort()

actual fun DoubleArray.sort()

actual fun FloatArray.sort()

actual fun CharArray.sort()

Сортирует массив на месте.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort()

// after sorting
println(intArray.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}

actual inline fun <T : Comparable<T>> Array<out T>.sort()

Сортирует массив на месте в соответствии с естественным порядком его элементов.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort()

// after sorting
println(people.joinToString()) // Sweyn Forkbeard, Bjorn Ironside, Ragnar Lodbrok 
   //sampleEnd
}

actual fun <T : Comparable<T>> Array<out T>.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort(0, 2)

// after sorting
println(people.joinToString()) // Bjorn Ironside, Ragnar Lodbrok, Sweyn Forkbeard 
   //sampleEnd
}

actual fun ByteArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun IntArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun LongArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun FloatArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun DoubleArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun CharArray.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort(0, 3)

// after sorting
println(intArray.joinToString()) // 2, 3, 4, 1 
   //sampleEnd
}

actual fun <T : Comparable<T>> MutableList<T>.sort()

Сортирует элементы списка на месте в соответствии с их естественным порядком сортировки.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Примеры

import kotlin.math.*
import kotlin.test.*

fun main() { 
   //sampleStart 
   val mutableList = mutableListOf(4, 3, 2, 1)

// before sorting
println(mutableList.joinToString()) // 4, 3, 2, 1

mutableList.sort()

// after sorting
println(mutableList.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}

inline fun <T> MutableList<T>.sort(comparator: Comparator<in T>)

Устарело (с ошибкой)

Вместо этого используйте sortWith(comparator).

Заменить на

this.sortWith(comparator)

inline fun <T> MutableList<T>.sort(comparison: (T, T) -> Int)

Устарело (с ошибкой)

Вместо этого используйте sortWith(Comparator(comparison)).

Заменить на

this.sortWith(Comparator(comparison))

Требования к платформе и версии: Native (1.3), Wasm-JS (1.8), Wasm-WASI (1.8)

actual fun IntArray.sort()

actual fun LongArray.sort()

actual fun ByteArray.sort()

actual fun ShortArray.sort()

actual fun DoubleArray.sort()

actual fun FloatArray.sort()

actual fun CharArray.sort()

Сортирует массив на месте.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort()

// after sorting
println(intArray.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}

actual fun <T : Comparable<T>> Array<out T>.sort()

Сортирует массив на месте в соответствии с естественным порядком его элементов.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort()

// after sorting
println(people.joinToString()) // Sweyn Forkbeard, Bjorn Ironside, Ragnar Lodbrok 
   //sampleEnd
}

actual fun <T : Comparable<T>> Array<out T>.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   class Person(val firstName: String, val lastName: String) : Comparable<Person> {
    override fun compareTo(other: Person): Int = this.lastName.compareTo(other.lastName)
    override fun toString(): String = "$firstName $lastName"
}

val people = arrayOf(
    Person("Ragnar", "Lodbrok"),
    Person("Bjorn", "Ironside"),
    Person("Sweyn", "Forkbeard")
)

// before sorting
println(people.joinToString()) // Ragnar Lodbrok, Bjorn Ironside, Sweyn Forkbeard

people.sort(0, 2)

// after sorting
println(people.joinToString()) // Bjorn Ironside, Ragnar Lodbrok, Sweyn Forkbeard 
   //sampleEnd
}

actual fun ByteArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun IntArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun LongArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun FloatArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun DoubleArray.sort(fromIndex: Int = 0, toIndex: Int = size)

actual fun CharArray.sort(fromIndex: Int = 0, toIndex: Int = size)

Сортирует диапазон массива на месте.

Параметры

fromIndex

начало диапазона для сортировки (включительно), по умолчанию — 0.

toIndex

конец диапазона для сортировки (не включительно), по умолчанию — размер этого массива.

Исключения

IndexOutOfBoundsException

если fromIndex меньше нуля или toIndex превышает размер этого массива.

IllegalArgumentException

если fromIndex больше toIndex.

Примеры

import kotlin.test.*

fun main() { 
   //sampleStart 
   val intArray = intArrayOf(4, 3, 2, 1)

// before sorting
println(intArray.joinToString()) // 4, 3, 2, 1

intArray.sort(0, 3)

// after sorting
println(intArray.joinToString()) // 2, 3, 4, 1 
   //sampleEnd
}

actual fun <T : Comparable<T>> MutableList<T>.sort()

Сортирует элементы списка на месте в соответствии с их естественным порядком сортировки.

Сортировка устойчивая. Это означает, что после сортировки равные элементы сохраняют взаимный порядок.

Примеры

import kotlin.math.*
import kotlin.test.*

fun main() { 
   //sampleStart 
   val mutableList = mutableListOf(4, 3, 2, 1)

// before sorting
println(mutableList.joinToString()) // 4, 3, 2, 1

mutableList.sort()

// after sorting
println(mutableList.joinToString()) // 1, 2, 3, 4 
   //sampleEnd
}

© 2010–2026 JetBrains s.r.o. and Kotlin Programming Language contributors
Licensed under the Apache License, Version 2.0.
https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.collections/sort.html