Kotlin Array의 메서드와 확장 함수 파헤치기 (3)

김성준·2022년 12월 21일

Kotlin

목록 보기

16/17

코틀린 Array의 확장 함수 파헤치기(3)

확장 함수(Extension Functions)

distinct, distnctBy

fun <T> Array<out T>.distinct(): List<T>

inline fun <T, K> Array<out T>.distinctBy(
    selector: (T) -> K
): List<T>

distinct : 배열에서 고유한 요소만을 포함하는 리스트를 반환합니다.
distnctBy : 배열에서 selector가 반환하는 고유한 키를 가진 요소만을 포함한 list를 반환합니다.

동일한 요소(동일한 키를 갖거나)는 첫번째 요소만 반환 리스트에 포함됩니다.

fun main() {
    val array: Array<String> = arrayOf("one", "two", "four", "four", "six", "two", "one", "tWo", "ONE")

    println(array.distinct()) // [one, two, four, six, tWo, ONE]
    println(array.distinctBy { it.uppercase() }) // [one, two, four, six]
}

drop, dropLast, dropWhile, dropLastWhile

fun <T> Array<out T>.drop(n: Int): List<T>

fun <T> Array<out T>.dropLast(n: Int): List<T>

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

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

drop: 0 ~ n - 1번째 인덱스까지 제거된 리스트를 반환합니다.
dropLast: size - 1 ~ size - n - 1번째 인덱스까지 제거된 리스트를 반환합니다.
dropWhile: 첫번째 요소부터 predicate을 만족하지 않는 요소가 나타날때 까지의 모든 요소를 제거한 리스트를 반환합니다.
dropLastWhile: 마지막 요소부터 predicate을 만족하지 않는 요소가 나타날때 까지의 모든 요소를 제거한 리스트를 반환합니다.

fun main() {
    val array: Array<String> = arrayOf("one", "two", "four", "four", "six", "two", "one", "tWo", "ONE")

    println(array.drop(4)) // [six, two, one, tWo, ONE]
    println(array.dropLast(4)) // [one, two, four, four, six]
    println(array.dropWhile { it.length <= 3}) // [four, four, six, two, one, tWo, ONE]
    println(array.dropLastWhile {it.length <= 3}) // [one, two, four, four]
}

elementAtOrElse, elementAtOrNull

inline fun <T> Array<out T>.elementAtOrElse(
    index: Int,
    defaultValue: (Int) -> T
): T

fun <T> Array<out T>.elementAtOrNull(index: Int): T?

elementAtOrElse: 해당 인덱스에 존재하는 요소를 반환합니다. 만약 인덱스가 배열의 범위를 넘어가면 defaultValue의 반환값이 반환됩니다.
elementAtOrNull: 해당 인덱스에 존재하는 요소를 반환합니다. 만약 인덱스가 배열의 범위를 넘어가면 null이 반환됩니다.

fun main() {
    val array: Array<Int> = Array(10) { it + 1 }
    val elementAtOrElse = array.elementAtOrElse(4) { index: Int ->
        "$index is Out Of Bound"
    }
    val outOfBoundElement = array.elementAtOrElse(15) { index: Int ->
        "$index is Out Of Bound"
    }
    val elementAtOrNull = array.elementAtOrNull(4)
    val nullElement = array.elementAtOrNull(15)

    println(elementAtOrElse) // 5
    println(outOfBoundElement) // 15 is Out Of Bound
    println(elementAtOrNull) // 5
    println(nullElement) // null
}

filter, filterIndexed, filterIndexedTo, filterIsInstance, filterIsInstanceTo, filterNot, filterNotNull, filterNotNullTo, filterNotTo, filterTo

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

inline fun <T> Array<out T>.filterIndexed(
    predicate: (index: Int, T) -> Boolean
): List<T>

inline fun <T, C : MutableCollection<in T>> Array<out T>.filterIndexedTo(
    destination: C,
    predicate: (index: Int, T) -> Boolean
): C

fun <reified R> Array<*>.filterIsInstance(): List<R>
(source)

fun <reified R, C : MutableCollection<in R>> Array<*>.filterIsInstanceTo(
    destination: C
): C

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

fun <T : Any> Array<out T?>.filterNotNull(): List<T>

fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo(
    destination: C
): C

inline fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo(
    destination: C,
    predicate: (T) -> Boolean
): C

inline fun <T, C : MutableCollection<in T>> Array<out T>.filterTo(
    destination: C,
    predicate: (T) -> Boolean
): C

filter: predicate가 true를 반환하는 요소들만 담긴 리스트를 반환합니다.
filterIndexed: predicate의 인자가 index, value를 갖습니다. 나머지는 filter와 동일함
filterIsInstance: 지정된 타입 파라미터의 인스턴스인 모든 요소를 포함하는 목록을 반환합니다.
filterNot: predicate이 false를 반환하는 요소들만 담긴 리스트를 반환합니다.
filterNotNull: 배열의 요소 중 null이 아닌 요소들만 담긴 리스트를 반환합니다.
(filter, filterIndexed, filterIsInstance, filterNot, filterNotNull)To: 필터링된 요소들이 추가될 destination 배열을 지정할 수 있습니다.

fun main() {
    val numberArray: Array<Number> 
    	= arrayOf(1, 1.5f, 2.3, 100L, 14.5f, 6.6, Double.NaN)
    val array: Array<Int> 
    	= Array(10) { it + 1 }
    val containNullArray: Array<Int?> 
    	= arrayOf(1, null, 2, 3, 4, null, 10, null, 12)
    val destination: MutableList<Int>
    	= mutableListOf(10, 143, 12)

    val filter = array.filter { it > 5 }
    val filterIndexed = array.filterIndexed { idx, i -> idx > 5 }
    val filterIsInstance = numberArray.filterIsInstance<Double>()
    val filterNot = array.filterNot { it > 5 }
    val filterNotNull = containNullArray.filterNotNull()
    val filterTo = array.filterTo(destination) { it > 5 }

    println(filter) // [6, 7, 8, 9, 10]
    println(filterIndexed) // [7, 8, 9, 10]
    println(filterIsInstance) // [2.3, 6.6, NaN]
    println(filterNot) // [1, 2, 3, 4, 5]
    println(filterNotNull) // [1, 2, 3, 4, 10, 12]
    println(filterTo) // [10, 143, 12, 6, 7, 8, 9, 10]
}

find, findLast

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

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

find: predicate이 true를 반환하는 첫번째 인자를 반환합니다 (앞에서 부터 순회). 존재하지 않으면 null을 반환합니다.
findLat: predicate이 true를 반환하는 첫번째 인자를 반환합니다 (뒤에서 부터 순회). 존재하지 않으면 null을 반환합니다.

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

    val find = array.find { it > 5 }
    val findLast = array.findLast { it > 5 }

    println(find) // 6
    println(findLast) // 10
}

first, firstOrNull, firstNotNullOf, firstNotNullOfOrNull

fun <T> Array<out T>.first(): T

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

fun <T> Array<out T>.firstOrNull(): T?

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


inline fun <T, R : Any> Array<out T>.firstNotNullOf(
    transform: (T) -> R?
): R

inline fun <T, R : Any> Array<out T>.firstNotNullOfOrNull(
    transform: (T) -> R?
): R?

first(): 첫번째 요소를 반환합니다. 크기가 0이면 NoSuchElementException이 발생합니다.
first(predicate: (T) -> Boolean): predicate이 true를 반환하는 첫번째 요소를 반환합니다. 존재하지 않으면 NoSuchElementException이 발생합니다.
firstNotNullOf: transform이 null이 아닌 값을 반환하는 첫번째 요소를 반환합니다. 그런 요소가 존재하지 않으면 NoSuchElementException이 발생합니다.
(first, firstNotNullOf)OrNull: NoSuchElementException이 발생하는 상황에서 null을 반환합니다.

fun main() {
    val array: Array<Int> = Array(10) { it + 1 }
    val containNullArray: Array<Int?> = arrayOf(null, 1, 2, null, 3, 4, 5)
    val allNullArray: Array<Int?> = arrayOf(null, null, null)

    val first = array.first()
    val firstPredicate = array.first { it > 5 }
    val firstNotNullOf = containNullArray.firstNotNullOf { it }
    val firstOrNull = array.firstOrNull { it < 1 }
    val firstNotNullOfOrNull = allNullArray.firstNotNullOfOrNull { it }

    println(first) // 1
    println(firstPredicate) // 6
    println(firstNotNullOf) // 1
    println(firstOrNull) // null
    println(firstNotNullOfOrNull) // null
}