Kotlin Koans 에서 Introduction 부분의 문제를 풀고 공부한 내용을 정리한 글 입니다.

Collection transformation operations

map() , mapIndexed()

val numbers = setOf(1, 2, 3)
println(numbers.map { it * 3 })
println(numbers.mapIndexed { idx, value -> value * idx })

결과
[3, 6, 9]
[0, 2, 6]

짝을 지어주는 함수 map() , 인덱스와 함께 사용할 수 있는 함수 mapIndexed()

mapNotNull() , mapIndexedNotNull()

val numbers = setOf(1, 2, 3)
println(numbers.mapNotNull { if (it == 2) null else it * 3 })
println(numbers.mapIndexedNotNull { idx, value -> if (idx == 0) null else value * idx })

/** 결과
[3, 9]
[2, 6]
**/

null을 포함하지 않는 함수를 사용해서 원하는 값을 뽑아 낼 수 있다.

인덱스의 값에 따라서도 원하는 값 추출 가능

⇒ 코테 문제 풀 때 유용하게 사용할 듯.

mapKeys() , mapValues()

val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key11" to 11)
println(numbersMap.mapKeys { it.key.uppercase() })
println(numbersMap.mapValues { it.value + it.key.length })

/** 
결과
{KEY1=1, KEY2=2, KEY3=3, KEY11=11}
{key1=5, key2=6, key3=7, key11=16}
**/

키값이나 vlaue값만 변경하고 싶을 때 사용하는 함수.

zip() , unZip()

val colors = listOf("red", "brown", "grey")
val animals = listOf("fox", "bear", "wolf")
println(colors zip animals)

val twoAnimals = listOf("fox", "bear")
println(colors.zip(twoAnimals))

/**
결과
[(red, fox), (brown, bear), (grey, wolf)]
[(red, fox), (brown, bear)]
**/

println(colors.zip(animals) { color, animal -> 
    "The ${animal.replaceFirstChar { it.uppercase() }} is $color"
})

/**
결과
[The Fox is red, The Bear is brown, The Wolf is grey]
**/

val numberPairs = listOf("one" to 1, "two" to 2, "three" to 3, "four" to 4)
println(numberPairs.unzip())
/**
결과
([one, two, three, four], [1, 2, 3, 4])
**/

두 컬렉션의 위치가 동일한 요소에서 쌍을 만드는 것.

만약 크기가 더 작은 컬렉션이 있다면 작은 컬렉션에 맞추게 됩니다!

AssociateWith()

val numbers = listOf("one", "two", "three", "four")
println(numbers.associateWith { it.length })

/**
{one=3, two=3, three=5, four=4}
**/

기본 연관 기능의 함수이고 반환값은 map 형식으로 반한된다.

두 요소가 같게 되면 마지막 요소만 맵에 남게 된다.

associateBy()

val numbers = listOf("one", "two", "three", "four")

println(numbers.associateBy { it.first().uppercaseChar() })
println(numbers.associateBy(
    keySelector = { it.first().uppercaseChar() }, 
    valueTransform = { it.length })
)

/**
{O=one, T=three, F=four}
{O=3, T=5, F=4}
**/

map 형식으로 반환되기 때문에 중복값이 저장될 수 없고 마지막으로 언급되는 값이 남게 되기 때문에 T = two 값은 사라졌다!

key와 value값을 모두 지정해서 연관지을 수도 있다.

associate()

val names = listOf("Alice Adams", "Brian Brown", "Clara Campbell")
println(names.associate { name -> 
    parseFullName(name).let { 
        it.lastName to it.firstName }
    }
 )

가장 간단하게 연관짓는 법. 성능이 중요하지 않거나 조건이 없을 때 사용.

flatten()

val numberSets = listOf(setOf(1, 2, 3), setOf(4, 5, 6), setOf(1, 2))
println(numberSets.flatten())

/**
[1, 2, 3, 4, 5, 6, 1, 2]
**/

list 또는 set을 하나의 리스트로 반환해주는 함수

flatMap()

val containers = listOf(
    StringContainer(listOf("one", "two", "three")),
    StringContainer(listOf("four", "five", "six")),
    StringContainer(listOf("seven", "eight"))
)
println(containers.flatMap { it.values })

/**
[one, two, three, four, five, six, seven, eight]
**/

flatten보다 훨씬 더 유연하게 단일화를 시켜주는 함수 리스트로 반환해줌.