sort

fun IntArray.sort()

fun LongArray.sort()

fun ByteArray.sort()

fun ShortArray.sort()

fun DoubleArray.sort()

fun FloatArray.sort()

fun CharArray.sort()

Sorts the array in-place.

import kotlin.test.*

fun main(args: Array<String>) {
//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
}

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

Sorts the array in-place according to the natural order of its elements.

The sort is stable. It means that equal elements preserve their order relative to each other after sorting.

import kotlin.test.*

fun main(args: Array<String>) {
//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
}

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

Sorts a range in the array in-place.

The sort is stable. It means that equal elements preserve their order relative to each other after sorting.

import kotlin.test.*

fun main(args: Array<String>) {
//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
}

Parameters

fromIndex - the start of the range (inclusive) to sort, 0 by default.

toIndex - the end of the range (exclusive) to sort, size of this array by default.

Exceptions

IndexOutOfBoundsException - if fromIndex is less than zero or toIndex is greater than the size of this array.

IllegalArgumentException - if fromIndex is greater than toIndex.

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

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

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

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

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

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

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

Sorts a range in the array in-place.

import kotlin.test.*

fun main(args: Array<String>) {
//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
}

Parameters

fromIndex - the start of the range (inclusive) to sort, 0 by default.

toIndex - the end of the range (exclusive) to sort, size of this array by default.

Exceptions

IndexOutOfBoundsException - if fromIndex is less than zero or toIndex is greater than the size of this array.

IllegalArgumentException - if fromIndex is greater than toIndex.

@ExperimentalUnsignedTypes fun UIntArray.sort()

@ExperimentalUnsignedTypes fun ULongArray.sort()

@ExperimentalUnsignedTypes fun UByteArray.sort()

@ExperimentalUnsignedTypes fun UShortArray.sort()

Sorts the array in-place.

import kotlin.test.*

fun main(args: Array<String>) {
//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)

Sorts a range in the array in-place.

import kotlin.test.*

fun main(args: Array<String>) {
//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
}

Parameters

fromIndex - the start of the range (inclusive) to sort, 0 by default.

toIndex - the end of the range (exclusive) to sort, size of this array by default.

Exceptions

IndexOutOfBoundsException - if fromIndex is less than zero or toIndex is greater than the size of this array.

IllegalArgumentException - if fromIndex is greater than toIndex.

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

Sorts elements in the list in-place according to their natural sort order.

The sort is stable. It means that equal elements preserve their order relative to each other after sorting.

import kotlin.test.*

fun main(args: Array<String>) {
//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> MutableList<T>.sort(comparator: Comparator<in T>)

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

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

Sorts the array in-place according to the order specified by the given comparison function.

The sort is stable. It means that equal elements preserve their order relative to each other after sorting.

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

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

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

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

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

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

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

Sorts the array in-place according to the order specified by the given comparison function.