코틀린 Array의 메서드와 확장 함수 파헤치기(2)

Array의 확장XXX들..

IDE에서 Array 객체를 생성하고 .을 눌러보면 Array와 관련된 다양한 함수들이 쭈르르륽 나열되는 것을 볼 수 있다.

하지만 이전 시간에 살펴 봤듯이 Array 클래스의 내부에는 1개의 프로퍼티와 4개의 메서드가 전부였다.

나머지 수많은 함수들은 어디에 존재하는걸까???

그 친구들은 Array 클래스 외부에 Array 클래스에 대한 확장 함수와 확장 프로퍼티의 형태로 존재한다.

이제부터 코틀린 Array 공식문서에 있는 함수들을 하나씩 살펴보자.

확장 프로퍼티(Extension Properties)

lastIndex

배열의 마지막 유효한 인덱스를 반환합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }
    // [0, 1, 4, 9, 16]
    
    println(array.lastIndex) // 16
    println(array[4] // 16
}

indices

배열의 유효한 인덱스의 범위를 반환합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }
    // [0, 1, 4, 9, 16]

    println(array.indices) // 0..4
    for (i in array.indices) {
    	print("$i ") // 0 1 2 3 4
        println("${array[i]} ") // 0 1 4 9 16
    }
}

확장 함수(Extension Functions)

all

inline fun <T> Array<out T>.all(
    predicate: (T) -> Boolean
): Boolean

배열의 모든 요소가 predicate을 만족하면 true를 반환하고, 그렇지 않다면 false를 반환합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }
    // [0, 1, 4, 9, 16]

    println(array.all { it < 20 }) // true
    println(array.all { it % 2 == 0})  // false
}

any

public inline fun <T> Array<out T>.any(predicate: (T) -> Boolean): Boolean

배열의 요소 중 하나라도 predicate을 만족하면 true를 반환하고, 그렇지 않다면 false를 반환합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }
    // [0, 1, 4, 9, 16]

    println(array.any { it > 20 }) // false
    println(array.any { it % 2 == 0})  // true
}

public fun <T> Array<out T>.any(): Boolean

배열이 하나의 요소라도 가지고 있다면 true를 반환하고 비어있다면 false를 반환합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }
    val emptyArray: Array<Int> = Array(0) { 0 }

    println(array.any()) // true
    println(emptyArray.any()) // false
}

asIterable

public fun <T> Array<out T>.asIterable(): Iterable<T>

원래 배열 래핑하는 Iterable 객체를 반환합니다. 이 Iterable 객체를 사용하여 반복하면 원래 배열의 요소를 순회할 수 있습니다.

빈 배열에 사용하면 비어있는 리스트가 반환됩니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }
    val emptyArray: Array<Int> = Array(0) { 0 }

    for (i in array.asIterable()) {
        println("$i ") // 0 1 4 9 16
    }

    println(emptyArray.asIterable()) // []
}

asSequence

public fun <T> Array<out T>.asSequence(): Sequence<T>

원래 배열을 래핑하는 시퀀스를 반환합니다. 이 시퀀스를 이용하여 반복하면 원래 배열의 요소에 접근할 수 있습니다.

비어있는 배열에 사용하면 비어있는 시퀀스를 반환합니다.

Sequence?

Sequence는 크기를 특정하고 있지 않다가 나중에 결정할 수 있는 특수한 컬렉션입니다. 처리 중에는 값을 결정하고 있지 않다가 toList 같은 메서드를 사용했을때, 최종적으로 값과 크기가 결정됩니다.

    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }

    val convertedArray = array.asSequence().map { it.toString() }.filter { it != "4" }.toList().toTypedArray()
    
    println(convertedArray.contentToString())

배열에 map으로 각 요소를 String으로 바꾸고 filter로 해당하는 요소를 제거하면 각 과정마다 List가 새로 생성됩니다.

하지만 시퀀스를 사용하면 각 요소의 값에대한 평가를 미루기 때문에 중간에 생성되는 리스트들이 생성되지 않습니다.

따라서 크기가 큰 배열에 컬렉션을 생성하는 함수를 체이닝하고 싶다면 시퀀스로 바꾸고 실행하면 시간이나 메모리 측면에서 이점을 가질 수 있습니다.

associate

public inline fun <T, K, V> Array<out T>
	.associate(transform: (T) -> Pair<K, V>): Map<K, V> 

transform 함수가 제공하는 키-값 쌍을 요소로 갖는 Map을 반환합니다.

중복되는 키가 존재하면 마지막 요소가 Map에 들어갑니다.

반환된 Map은 원래 배열의 순서를 유지합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }
    val titleArray: Array<String> = arrayOf("one", "two", "three", "four", "five")

    val associateMap = array.associate{ arrayValue: Int ->
        val idx = array.indexOf(arrayValue)
        Pair(titleArray[idx], arrayValue)
    }

    println(associateMap)
}

/* [출력]
 * {one=0, two=1, three=4, four=9, five=16}
 */

associateBy

public inline fun <T, K> Array<out T>
	.associateBy(keySelector: (T) -> K): Map<K, T>

keySelector 함수가 제공하는 키와 배열의 요소를 값으로 하는 Map을 반환합니다.

중복되는 키가 존재하면 마지막에 해당하는 요소가 Map에 들어갑니다.

반환된 Map은 원래 배열의 순서를 유지합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }

    val associateByMap = array.associateBy{ arrayValue: Int ->
        array.indexOf(arrayValue)
    }

    println(associateByMap)
}
/* [출력]
 * {0=0, 1=1, 2=4, 3=9, 4=16}
 */

associateByTo

public inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.
	associateByTo(
    	destination: M, 
    	keySelector: (T) -> K, 
    	valueTransform: (T) -> V
    ): M

keySelector와 valueTransform 함수가 제공하는 key와 value를 키-값으로 하는 destination 인자에 해당하는 Map을 반환합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }

    val associateByToMap = array.associateByTo(
        destination = LinkedHashMap<String, Int>(),
        keySelector = { arrayValue: Int ->
            when (array.indexOf(arrayValue)) {
                0 -> "one"
                1 -> "two"
                2 -> "three"
                3 -> "four"
                4 -> "five"
                else -> "none"
            }
        },
        valueTransform = { arrayValue: Int ->
            arrayValue
        }
    )

    println(associateByToMap)
}
/* [출력]
 * {one=0, two=1, three=4, four=9, five=16}
 */

public inline fun <T, K, M : MutableMap<in K, in T>> Array<out T>.
associateByTo(
	destination: M,
	keySelector: (T) -> K
    ): M

valueTransform 인자를 생략하여 keySelector로 키만 지정할 수도 있습니다. valueTransform 인자를 생략하면, value는 자동으로 Array의 요소들이 됩니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }

    val associateByToMap = array.associateByTo(
        destination = LinkedHashMap<String, Int>(),
        keySelector = { arrayValue: Int ->
            when (array.indexOf(arrayValue)) {
                0 -> "one"
                1 -> "two"
                2 -> "three"
                3 -> "four"
                4 -> "five"
                else -> "none"
            }
        }
    )

    println(associateByToMap)
}

/* [출력]
 * {one=0, two=1, three=4, four=9, five=16}
 */

associateTo

public inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>
	.associateTo(destination: M, transform: (T) -> Pair<K, V>): M

기존에 존재하는 Map을 destination 인자에 넣어 확장할 수 있습니다.

destination에 transform이 제공하는 키-값 쌍을 추가한 destination을 반환합니다.

fun main() {
    val array: Array<Int> = Array(5) { idx: Int -> idx * idx }
    val titleArray: Array<String> = arrayOf("one", "two", "three", "four", "five")
    val destination = LinkedHashMap<String, Int>()

    destination["six"] = 25
    destination["seven"] = 36
    
    val associateToMap = array.associateTo(
        destination = destination,
        transform = { arrayValue: Int ->
            titleArray[array.indexOf(arrayValue)] to arrayValue
        }
    )

    println(associateToMap)
}

/* [출력]
 * {six=25, seven=36, one=0, two=1, three=4, four=9, five=16}
 */

associateWith

public inline fun <K, V> Array<out K>
	.associateWith(valueSelector: (K) -> V): Map<K, V>

배열의 각 요소를 key로하고 valueSelector의 반환값을 value로 하는 Map을 반환합니다.

중복되는 키가 존재하면 마지막 요소가 Map에 남게됩니다.

fun main() {
    val titleArray: Array<String> = arrayOf("one", "two", "three", "four", "five")

    val associateWithMap = titleArray.associateWith(
        valueSelector = { arrayValue: String ->
            titleArray.indexOf(arrayValue)
        }
    )

    println(associateWithMap)
}

/* [출력]
 * {one=0, two=1, three=2, four=3, five=4}
 */

associateWithTo

public inline fun <K, V, M : MutableMap<in K, in V>> Array<out K>
	.associateWithTo(destination: M, valueSelector: (K) -> V): M

associateWith와 동일하지만 destination을 지정해 기존에 존재하는 Map을 확장할 수 있습니다.

fun main() {
    val titleArray: Array<String> = arrayOf("one", "two", "three", "four", "five")

    val destination = LinkedHashMap<String, Int>()

    destination["six"] = 5
    destination["eight"] = 7

    val associateWithToMap = titleArray.associateWithTo(
        destination = destination,
        valueSelector = { arrayValue: String ->
            titleArray.indexOf(arrayValue)
        }
    )

    println(associateWithToMap)
}

/* [출력]
 * {six=5, eight=7, one=0, two=1, three=2, four=3, five=4}
 */

average

@JvmName("averageOfByte") fun Array<out Byte>.average(): Double

@JvmName("averageOfShort") fun Array<out Short>.average(): Double

@JvmName("averageOfInt") fun Array<out Int>.average(): Double

@JvmName("averageOfLong") fun Array<out Long>.average(): Double

@JvmName("averageOfFloat") fun Array<out Float>.average(): Double

@JvmName("averageOfDouble") fun Array<out Double>.average(): Double

배열의 요소에 대한 평균을 반환합니다.

배열의 크기가 0이면 Double.NaN을 반환하고 그렇지 않다면 평균값을 반환합니다.

fun main() {
    val array: Array<Int> = Array(5) { it + 1 }
    val emptyArray: Array<Int> = arrayOf()

    println(array.average()) // 3.0
    println(emptyArray.average()) // NaN
}

binarySearch

public fun <T> Array<out T>
	.binarySearch(
    	element: T,
        comparator: Comparator<in T>,
        fromIndex: Int = 0,
        toIndex: Int = size
        ): Int

이분탐색 알고리즘을 사용하여 배열을 탐색하여 해당 요소를 찾아 인덱스를 반환합니다. 배열은 comparator 인자로 정렬되어 있을 것이라고 기대합니다. 만약, 그렇지 않으면 결과는 정의 되지 않습니다(undefined).

만약 배열에 찾고자 하는 요소와 똑같은 요소가 여러개 존재하면, 어떤 요소가 찾아질지는 보장될 수 없습니다.

fromIndex가 0보다 작거나 toIndex가 배열의 크기보다 크면IndexOutOfBoundsException 예외가 발생합니다.

fromIndex가 toIndex보다 크면 IllegalArgumentException 예외가 발생합니다.

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

전반적인 설명은 위와 같습니다. 배열이 오름차순으로 정렬되어 있을것이라고 기대합니다.

fun main() {
    val array: Array<Int> = Array(100) { it + 5 }
    val targetIndex = array.binarySearch(7)

	val array: Array<Int> = Array(100) { it + 5 }
    
    println(targetIndex) // 2
}

fun main() {
    val arrayDescending: Array<Int> = Array(100) { it + 5 }
    	.sortedArrayDescending()
    val targetIndex = arrayDescending.binarySearch(7) { o1, o2 ->
        o2 - o1
    }
    println(targetIndex) // 97
}

component1, 2, 3, 4, 5

public inline operator fun <T> Array<out T>.component1(): T

public inline operator fun <T> Array<out T>.component2(): T

public inline operator fun <T> Array<out T>.component3(): T

public inline operator fun <T> Array<out T>.component4(): T

public inline operator fun <T> Array<out T>.component5(): T

componentN은 N번 인덱스에 해당하는 배열의 요소를 반환합니다.

배열의 크기가 N보다 작으면, IndexOutOfBoundsException 예외가 발생합니다.
(Kotlin/JS 제외)

fun main() {
    val arrayDescending: Array<Int> = Array(5) { it + 5 }.sortedArrayDescending()

    println(arrayDescending.component1()) // 5
    println(arrayDescending.component2()) // 4
    println(arrayDescending.component3()) // 3
    println(arrayDescending.component4()) // 2
    println(arrayDescending.component5()) // 1
}

contains

operator fun <T> Array<out T>.contains(element: T): Boolean

배열에 해당 요소가 존재하면 true를 반환하고 그렇지 않으면 false를 반환합니다.

fun main() {
	val array = Array(10) { it + 1 }
    
    println(array.contains(5)) // true
    println(5 in array) // true
}

array.contatins(5)와 5 in array는 동일한 동작을 수행합니다.

count

fun <T> Array<out T>.count(): Int

배열에 몇개의 요소가 존재하는지 반환합니다.

fun main() {
    val arrayDescending: Array<Int> = Array(5) { it + 1 }
    	.sortedArrayDescending()

    println(arrayDescending.count()) // 5
}

inline fun <T> Array<out T>.count(
    predicate: (T) -> Boolean
): Int

predicate이 true를 반환하는 배열의 요소가 몇개인지를 반환합니다.

fun main() {
    val arrayDescending: Array<Int> = Array(5) { it + 1 }
    	.sortedArrayDescending()

    println(arrayDescending.count { it > 2 }) // 3
}

출처

코틀린 공식문서