sort (original) (raw)

Sorts the array in-place.

Since Kotlin

1.3

Samples

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
}

Sorts a range in the array in-place.

Since Kotlin

1.4

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.

Throws

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

Samples

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
}

Sorts the array in-place.

Since Kotlin

1.0

Samples

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
}

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.

Since Kotlin

1.0

Samples

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
}

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.

Since Kotlin

1.4

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.

Throws

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

Samples

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
}

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.

Since Kotlin

1.0

Samples

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
}

Sorts the array in-place.

Since Kotlin

1.1

Samples

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
}

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.

Since Kotlin

1.1

Samples

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
}

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.

Since Kotlin

1.4

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.

Throws

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

Samples

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
}

Sorts a range in the array in-place.

Since Kotlin

1.4

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.

Throws

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

Samples

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
}

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.

Since Kotlin

1.1

Samples

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
}

Deprecated

Warning since 1.6

Use sortWith instead

Replace with

this.sortWith(Comparator(comparison))

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.

Since Kotlin

1.1

Deprecated

Warning since 1.6

Use other sorting functions from the Standard Library

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

Since Kotlin

1.1

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.

Since Kotlin

1.0

Throws

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.

Since Kotlin

1.0

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.

Throws

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

Samples

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
}

Sorts the array in-place.

Since Kotlin

1.0

Samples

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
}

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.

Since Kotlin

1.0

Samples

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
}

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.

Since Kotlin

1.4

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.

Throws

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

Samples

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
}

Sorts a range in the array in-place.

Since Kotlin

1.0

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.

Throws

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

Samples

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
}

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.

Since Kotlin

1.0

Samples

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
}

Deprecated (with error)

Use sortWith(comparator) instead.

Replace with

this.sortWith(comparator)

Since Kotlin

1.0

Deprecated (with error)

Use sortWith(Comparator(comparison)) instead.

Replace with

this.sortWith(Comparator(comparison))

Since Kotlin

1.0

Sorts the array in-place.

Since Kotlin

1.3

Samples

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
}

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.

Since Kotlin

1.3

Samples

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
}

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.

Since Kotlin

1.4

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.

Throws

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

Samples

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
}

Sorts a range in the array in-place.

Since Kotlin

1.4

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.

Throws

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

Samples

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
}

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.

Since Kotlin

1.3

Samples

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
}

Sorts the array in-place.

Since Kotlin

1.8

Samples

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
}

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.

Since Kotlin

1.8

Samples

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
}

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.

Since Kotlin

1.8

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.

Throws

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

Samples

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
}

Sorts a range in the array in-place.

Since Kotlin

1.8

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.

Throws

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

Samples

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
}

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.

Since Kotlin

1.8

Samples

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
}

Sorts the array in-place.

Since Kotlin

1.8

Samples

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
}

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.

Since Kotlin

1.8

Samples

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
}

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.

Since Kotlin

1.8

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.

Throws

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

Samples

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
}

Sorts a range in the array in-place.

Since Kotlin

1.8

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.

Throws

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

Samples

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
}

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.

Since Kotlin

1.8

Samples

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
}