컬렉션 확장 함수

• 연산자(operators) 기능의 메서드 : 더하고 빼는 기능
• 집계(aggregators) 기능의 메서드 : 최대, 최소, 집합, 총합 기능
• 검사(checks) 기능의 메서드 : 요소를 검사, 순환
• 필터(filtering) 기능의 메서드 : 원하는 요소를 골라내는 기능
• 변환(transformers) 기능의 메서드 : 뒤집기, 정렬, 자르기 등 변환 기능

요소 집계를 위한 확장 함수

• foreach, forEachIndexed, onEach, count, max, min, maxBy, minBy, fold, reduce, sumBy

요소의 순환

list.forEach()

람다 식 처리 후 컬렉션 반환 X

val list = listOf(1,2,3,4,5,6)
list.forEachIndexed { index, value -> println("index[$index] : $value") } // 인덱스

[결과]
index[0] : 1
index[1] : 2
index[2] : 3
index[3] : 4
index[4] : 5
index[5] : 6

list.onEach()

람다 식 처리 후 컬렉션 반환 O

val list = listOf(1,2,3,4,5,6)
val map = mapOf(11 to "Java", 22 to "Kotlin", 33 to "C++")
val returnList = list.onEach { println(it) }
println()
val returnedMap = map.onEach { println("key: ${it.key}, value: ${it.value}") }
println("returnList = $returnList")
println("returnMap = $returnedMap")

[결과]
returnList = [1, 2, 3, 4, 5, 6]
returnMap = {11=Java, 22=Kotlin, 33=C++}

list.fold() vs list.reduce()

• fold() : 초기값과 정해진 식에 따라 처음 요소 부터 끝 요소에 적용해 값 반환
• reduce() : fold 와 동일하나 초기값을 사용하지 않는다

val list3 = listOf(1,2,3,4,5,6)
println(list.fold(4) { total, next -> total + next })
println(list.foldRight(4) { total, next -> total + next })
println(list.reduce { total, next -> total + next })

[결과]
25
25
21

필터

특정 요소를 골라내기

• 특정 식에 따라 요소를 골라내기
• 인덱스 추출
• 가변형 컬렉션으로 변환
• 맵에서 키 혹은 값으로 추출
• 요소의 자료형에 따른 추출 등을 수행

val list = listOf(1,2,3,4,5,6)
println(list.filter { it % 2 == 0}) // 짝수 요소
println(list.filterNot [ it % 2 == 0}) // 짝수 이외의 요소

val listWithNull = listOf(1,null, 3, null, 5, 6)
println(listWithNull.ffilterNotNull()) // null제외 요소

list.filterIndexed()

특정 인덱스와 함께 추출

// filterIndexed 인덱스와 함께 추출
list.filterIndexed { idx, value -> idx != 1 && value % 2 == 0 }

// filterIndexedTo 추출 후 mutable 컬렉션으로 변환
val mutList = list.filterIndexedTo(MutableListOf()) { idx, value -> idx != 1 && value % 2 == 0 }

• 두개의 인자를 람다식에서 받아서 각각 인덱스와 값에 대해 특정 수식에 맞는 조건을 골라낼 수 있다
• filterIndexedTo 는 여기에 컬렉션으로 변환되는 기능이 추가

필터와 추출에 대한 연산

map.filterKeys() or map.filterValues()

• filterKeys 키
• filterValues 값

val map = mapOf(11 to "Java", 22 to "Kotlin", 33 to "C++")
map = map.filterKeys { it != 11 }
println(map) // {22=Kotlin, 33=C++}
map = map.filterValues { it == "Kotlin" } // {22=Kotlin}

list.filterIskotlinInstance()

특정 자료형에 대한 필터

val listMixed = listOf(1,"Hello", 3, "World", 5, 'A')
// 여러 자료형의 요소중 원하는 자료형을 골라냄
println("filterIsInstance: " + listMixed.filterIsInstance<String>())

특정 범위 잘라내거나 반환

list.slice()

val list = listOf(1,2,3,4,5,6)
println(list.slice(listOf(0,1,2))) // [1,2,3]

• 인덱스 0~2에 해당하는 1,2,3이 list에서 추출되 반환

list.take()

println(list.tack(2)) // 앞의 두 요소 반환 [1,2]
println(list.takeLast(2)) // 마지막 요소의 두 요소 반환 [5,6]
println(list.takeWhile{ it < 3 }) // 조건식에 따른 반환 [1,2]

• drop을 사용하면 take와 정반대로 제외하여 반환한다

특정 요소 골라내기

list.distinct()

• 여러 중복 요소가 있으면 하나로 취급하여 다시 컬렉션 LIST로 반환

val list = listOF(2,2,3,4,5,5,6)
println("distinct: "+ list.distinct()) // [2,3,4,5,6]

list.intersect()

• 교집합의 원리로 겹치는 요소만 골라내 컬렉션 LIST 로 반환

printl("intersect: " + list.intersect(listOf(5,6,7,8))) // [5,6]

MAP 연산

list.map()

• 주어진 컬렉션의 요소를 일괄적으로 모든 요소에 식을 적용해 새로운 컬렉션을 만듬
• foreach와는 다르게 주어진 컬렉션을 건드리지 않는다

val list = listOf(1,2,3,4,5,6)

// 컬렉션에 주어진 요소들로 새로운 컬렉션을 반환
print(list.map{it * 2}) // [2,4,5,8,10,12]

// 컬렉션에 인덱스를 포함하여 새로운 컬렉션을 반환
print(list.mapIndexed{ index,it -> index  * it}) // [0,2,6,12,20,30]

val listWithNull = listOf(1,null,3,null,5,6)
// null을 제외하고 식을 적용하여 새로운 컬렉션을 반환한다
println(listWithNull.mapNotNull{ it?.times(2) }) // [2,6,10,12]

list.flatMap()

• 각 요소에 식을 적용한 후 이것을 다시 하나로 합쳐 새로운 컬렉션을 반환

val list = listOf(1,2,3,4,5,6)
print(list.flatMap{ listOf(it, 'A') }) // [1, A, 2, A, 3, A, 4, A, 5, A, 6, A]
val result = listOf("abc","12").flatMap{ it.toList() }
println(result) // [a, b, c, 1, 2]

list.groupBy()

• 주어진 식에 따라 요소를 그룹화 하고 이것을 다시 Map으로 반환

val list = listOf(1,2,3,4,5,6)
val groupMap = list.groupBy{ if (it % 2 == 0) "even" else "odd" }
println(groupMap) // {odd=[1,3,5], even=[2,4,6]}

요소 처리와 검색 연산

list.element()

• 보통 인덱스와 함께 해당 요소의 값을 반환
• 식에 따라 처리하거나 인덱스를 벗어나면 null을 반환

val list = listOf(1,2,3,4,5,6)

// 인덱스에 해당하는 요소를 반환
println(list.elementAt(1)) // 2

// 인덱스를 벗어나는 경우 식에 따라 결과 반환 아니면 요소 반환
println(list.elementAtOrElse(10, {2*it})) // 20

// 인덱스를 벗어나는 경우 null 반환
println(list.elementAtOrNull(10)) // null

순서와 정렬 연산

• reversed()
• sorted()
• sortedDescending()
• sortedBy{it % 3}
• sortedByDescending {it % 3}