Skip to content

컬렉션 정렬 ​

요소의 순서는 특정 컬렉션 타입에서 중요한 특성입니다. 예를 들어, 두 리스트가 동일한 요소를 포함하더라도 요소의 순서가 다르면 서로 같은 것으로 간주되지 않습니다.

Kotlin에서는 객체의 순서를 여러 가지 방법으로 정의할 수 있습니다.

첫 번째로는 자연 순서(natural order)가 있습니다. 이는 Comparable 인터페이스를 구현한 타입에 대해 정의됩니다. 다른 순서가 지정되지 않았을 때 요소를 정렬하는 데 자연 순서가 사용됩니다.

대부분의 기본 내장 타입은 비교 가능(comparable)합니다.

  • 숫자 타입은 전통적인 수치 순서를 사용합니다. 1은 0보다 크고, -3.4f는 -5f보다 큽니다.
  • Char 및 String은 사전식 순서(lexicographical order)를 따릅니다. b는 a보다 크고, world는 hello보다 큽니다.

사용자 정의 타입에 자연 순서를 정의하려면 해당 타입이 Comparable을 구현하도록 만듭니다. 이를 위해 compareTo() 함수를 구현해야 합니다. compareTo()는 동일한 타입의 다른 객체를 인자로 받아 어느 객체가 더 큰지를 나타내는 정수 값을 반환해야 합니다.

  • 양수 값은 수신 객체가 더 큼을 나타냅니다.
  • 음수 값은 수신 객체가 인자보다 작음을 나타냅니다.
  • 0은 두 객체가 같음을 나타냅니다.

아래는 메이저(major)와 마이너(minor) 부분으로 구성된 버전을 정렬하기 위한 클래스입니다.

kotlin
class Version(val major: Int, val minor: Int): Comparable<Version> {
    override fun compareTo(other: Version): Int = when {
        this.major != other.major -> this.major compareTo other.major // 중위 표기법(infix) 형태의 compareTo() 
        this.minor != other.minor -> this.minor compareTo other.minor
        else -> 0
    }
}

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

커스텀 순서(custom orders)를 사용하면 원하는 방식대로 모든 타입의 인스턴스를 정렬할 수 있습니다. 특히, 비교 불가능한(non-comparable) 객체에 순서를 정의하거나, 비교 가능한 타입에 대해 자연 순서 이외의 순서를 정의할 수 있습니다. 타입에 대한 커스텀 순서를 정의하려면 해당 타입을 위한 Comparator를 생성합니다. Comparator는 compare() 함수를 포함하고 있습니다. 이 함수는 클래스의 두 인스턴스를 인자로 받아 둘 간의 비교 결과를 정수로 반환합니다. 반환 결과는 앞서 설명한 compareTo()의 결과와 동일한 방식으로 해석됩니다.

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

lengthComparator를 사용하면 기본 사전식 순서 대신 문자열의 길이에 따라 문자열을 정렬할 수 있습니다.

Comparator를 정의하는 더 간결한 방법은 표준 라이브러리의 compareBy() 함수를 사용하는 것입니다. compareBy()는 인스턴스로부터 Comparable 값을 생성하는 람다 함수를 받아, 생성된 값의 자연 순서를 기준으로 커스텀 순서를 정의합니다.

compareBy()를 사용하면 위 예제의 길이 비교기를 다음과 같이 작성할 수 있습니다.

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

여러 기준을 기반으로 순서를 정의할 수도 있습니다. 예를 들어, 문자열을 길이 기준으로 먼저 정렬하고 길이가 같으면 알파벳순으로 정렬하려면 다음과 같이 작성할 수 있습니다.

kotlin
fun main() {
    val sortedStrings = listOf("aaa", "bb", "c", "b", "a", "aa", "ccc")
        .sortedWith { a, b -> 
           when (val compareLengths = a.length.compareTo(b.length)) {
             0 -> a.compareTo(b)
             else -> compareLengths
           }
         }

    println(sortedStrings)
    // [a, b, c, aa, bb, aaa, ccc]
}

여러 기준으로 정렬하는 것은 흔한 시나리오이므로, Kotlin 표준 라이브러리는 보조 정렬 규칙을 추가할 수 있는 .thenBy() 함수를 제공합니다.

예를 들어, 이전 예제와 동일하게 문자열을 길이순으로 먼저 정렬한 후 알파벳순으로 정렬하기 위해 compareBy()와 .thenBy()를 결합할 수 있습니다.

kotlin
fun main() {
    val sortedStrings = listOf("aaa", "bb", "c", "b", "a", "aa", "ccc")
        .sortedWith(compareBy<String> { it.length }.thenBy { it })

    println(sortedStrings)
    // [a, b, c, aa, bb, aaa, ccc]
}

Kotlin 컬렉션 패키지는 자연 순서, 커스텀 순서, 심지어 무작위 순서로 컬렉션을 정렬하는 함수를 제공합니다. 이 페이지에서는 읽기 전용(read-only) 컬렉션에 적용되는 정렬 함수를 설명합니다. 이 함수들은 요청된 순서대로 정렬된 원본 컬렉션의 요소를 담은 새 컬렉션을 결과로 반환합니다. 가변(mutable) 컬렉션을 제자리에서(in place) 정렬하는 함수에 대해 알아보려면 List 전용 연산을 참조하세요.

자연 순서 ​

기본 함수인 .sorted()와 .sortedDescending()은 자연 순서에 따라 오름차순 및 내림차순으로 정렬된 컬렉션의 요소를 반환합니다. 이 함수들은 Comparable 요소로 이루어진 컬렉션에 적용됩니다.

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

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

커스텀 순서 ​

커스텀 순서로 정렬하거나 비교 불가능한 객체를 정렬하기 위해 .sortedBy() 및 .sortedByDescending() 함수가 제공됩니다. 이 함수들은 컬렉션 요소를 Comparable 값으로 매핑하는 선택기(selector) 함수를 받아, 해당 값들의 자연 순서에 따라 컬렉션을 정렬합니다.

kotlin
fun main() {
    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")
}

컬렉션 정렬에 커스텀 순서를 정의하려면 고유한 Comparator를 제공할 수 있습니다. 이를 위해 Comparator를 인자로 전달하여 .sortedWith() 확장 함수를 호출합니다. 이 함수를 사용하면 문자열 길이에 따른 정렬이 다음과 같이 구현됩니다.

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

정렬 순서 확인 ​

다음 확장 함수들을 사용하여 요소들이 이미 특정 순서를 따르고 있는지 확인할 수 있습니다.

  • .isSorted()
  • .isSortedDescending()
  • .isSortedWith(comparator)
  • .isSortedBy(selector)
  • .isSortedByDescending(selector)

이 확장 함수들은 요소가 지정된 순서대로 배치되어 있거나 요소가 2개 미만인 경우 true를 반환합니다. 순서가 맞지 않는 쌍을 발견하는 즉시 확인을 중단하고 false를 반환합니다.

HashSet과 같이 반복(iteration) 순서가 보장되지 않는 컬렉션의 경우, 호출할 때마다 결과가 달라질 수 있습니다. 일관된 순서로 요소를 생성하지 않는 시퀀스(sequence)의 경우도 마찬가지입니다. 호출 간에 동일한 결과를 얻으려면 List와 같이 반복 순서가 보장된 컬렉션에서만 이러한 함수를 사용하세요.

Double 및 Float 값을 확인할 때, 이 함수들은 NaN을 다른 모든 값보다 큰 것으로 취급하고 -0.0을 0.0보다 작은 것으로 취급합니다. 또한 .isSortedBy() 및 .isSortedByDescending() 함수는 선택기 결과가 null인 경우 이를 non-null 값보다 작은 것으로 취급합니다.

시퀀스에서 이러한 함수를 호출할 때 해당 연산은 종단 연산(terminal operation)입니다. 다른 시퀀스를 반환하는 대신 시퀀스를 소비하여 Boolean 값을 생성합니다.

이러한 정렬 순서 확인 함수는 배열(arrays), 기본 타입 배열(primitive arrays), 부호 없는 배열(unsigned arrays)에서도 사용할 수 있습니다. 부호 없는 배열 및 이에 대한 연산은 실험적(Experimental) 기능이므로 @ExperimentalUnsignedTypes 애너테이션을 통한 옵트인(opt-in)이 필요합니다.

다음은 .isSorted() 및 .isSortedBy() 함수를 사용하여 정렬 순서를 확인하는 예제입니다.

kotlin
data class User(val name: String, val age: Int)

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    println(numbers.isSorted())
    // true

    val users = listOf(
        User("Alice", 24),
        User("Bob", 31),
        User("Charlie", 29),
    )
    println(users.isSortedBy(User::age))
    // false

    val descending = listOf(4, 3, 2, 1)
    println(descending.isSortedDescending())
    // true
   
}

역순 ​

.reversed() 함수를 사용하여 컬렉션을 역순으로 가져올 수 있습니다.

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

.reversed() 확장 함수는 요소들의 복사본이 담긴 새 컬렉션을 반환합니다. 따라서 나중에 원본 컬렉션을 변경하더라도 이전에 얻은 .reversed()의 결과에는 영향을 주지 않습니다.

또 다른 뒤집기 함수인 .asReversed()는 동일한 컬렉션 인스턴스의 역순 뷰(view)를 반환하므로, 원본 리스트가 변경되지 않는 상황이라면 .reversed()보다 더 가볍고 선호될 수 있습니다.

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

원본 리스트가 가변(mutable)인 경우, 원본의 모든 변경 사항이 역순 뷰에 반영되며 그 반대도 마찬가지입니다.

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

그러나 리스트의 가변성 여부를 알 수 없거나 원본이 리스트가 아닌 경우에는 결과가 나중에 변경되지 않는 복사본인 .reversed()를 사용하는 것이 더 바람직합니다.

무작위 순서 ​

마지막으로 컬렉션 요소를 무작위 순서로 담은 새 List를 반환하는 함수인 .shuffled()가 있습니다. 인자 없이 호출하거나 Random 객체를 전달하여 호출할 수 있습니다.

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