Do it! 코틀린 프로그래밍, 09-4 컬렉션의 확장 함수

확장 함수의 종류

• 연산자(Operator)
  • 더하고 빼는 등의 계산
• 집계(Aggregator)
  • 최대, 최소, 집합, 총합 등의 계산
• 검사(Check)
  • 요소를 검사하고 순환
• 필터(Filter)
  • 원하는 요소를 골라냄
• 변환(Transformer)
  • 뒤집기, 정렬, 자르기 등

컬렉션의 연산

fun main() {
    val list1 = listOf("1", "2", "3")
    val list2 = listOf(1, 2, 3)
    val map1 = mapOf("hi" to 1, "hello" to 2, "bye" to 3)

    println(list1 + "4")
    println(list2 + 4)
    println(list2 + listOf(5, 6, 7))
    println(list2 - 2)
    println(list2 - listOf(2, 3, 4))
    println(map1 + Pair("Bye", 4))
    println(map1 - "hi")
    println(map1 + mapOf("apple" to 5, "orange" to 6))
    println(map1 - listOf("hi", "hello"))
}

//[1, 2, 3, 4]
//[1, 2, 3, 4]
//[1, 2, 3, 5, 6, 7]
//[1, 3]
//[1]
//{hi=1, hello=2, bye=3, Bye=4}
//{hello=2, bye=3}
//{hi=1, hello=2, bye=3, apple=5, orange=6}
//{bye=3}

요소의 처리와 집계

fun main() {
    val list = listOf(1, 2, 3, 4, 5, 6)
    val listPair = listOf(Pair("a", 1), Pair("b", 2), Pair("c", 3))
    val map = mapOf(11 to "java", 22 to "kotlin", 33 to "cpp")

    println("// 요소의 순환")
    list.forEach({ x -> print(x) })
    println()
    list.forEach({ print(it) })
    println()
    list.forEach { print(it) }
    println()
    list.forEachIndexed { index, i -> println("$index : $i") }

    println("// onEach : 각 요소를 람다식으로 처리 후 컬렉션으로 반환")
    val returnList = list.onEach { print(it) }
    println()
    val returnedMap = map.onEach { println("${it.key}, ${it.value}") }
    println(returnList)
    println(returnedMap)

    println("// count: 특정 조건에 맞는 요소 개수 반환")
    println(list.count { it % 2 == 0 })

    println("// max/min : 최댓값 요소와 최솟값 요소의 반환")
    println(list.maxOrNull())
    println(list.minOrNull())

    println("// maxBy, minBy : 최대값과 최솟값으로 나온 요소 it에 대한 식의 결과")
    println(map.maxByOrNull { it.key }) // 키를 기준으로 최댓값
    println(map.minByOrNull { it.key }) // 키를 기준으로 최솟값

    println("// fold : 초깃값과 정해진 식에 따라 처음 요소부터 끝 요소에 적용하며 값을 생성")
    println(list.fold(4) { acc, i -> acc + i })
    println(list.fold(1) { acc, i -> acc * i })
    println("// foldRight : fold와 같고 마지막 요소에서 처음 요소로 반대로 적용")
    println(list.foldRight(4) { i, acc -> acc + i })
    println(list.foldRight(1) { i, acc -> acc * i })
    println("// fold : fold와 동일하지만 초깃값을 사용하지 않음")
    println(list.reduce { acc, i -> acc + i })
    println(list.reduceRight { i, acc -> i + acc })

    println("// sumBy :  식에 의해 도출된 모든 요소를 합산")
    println(listPair.sumOf { it.second })

    println("// all : 모든 요소가 일치해야 true")
    println(list.all { it < 10 })
    println(list.all { it % 2 == 0 })
    println("//any : 하나 이상의 요소가 일치하면 true")
    println(list.any { it % 2 == 0 })
    println(list.any { it > 0 })

    println("// contains : 요소가 포함되어 있으면 true")
    println(list.contains(2))
    println(2 in list)
    println(map.contains(33))
    println(33 in map)

    println("// containsAll : 모든 요소가 포함되어 있으면 true")
    println(list.containsAll(listOf(1, 2, 3)))

    println("// none : 요소가 없으면 true, 있으면 false")
    println(list.none())
    println(list.none { it > 100 })

    println("// isEmpty / isNotEmpty : 컬렉션이 비어 있는지 아닌지 검사")
    println(list.isEmpty())
    println(list.isNotEmpty())
}

//// 요소의 순환
//123456
//123456
//123456
//0 : 1
//1 : 2
//2 : 3
//3 : 4
//4 : 5
//5 : 6
//// onEach : 각 요소를 람다식으로 처리 후 컬렉션으로 반환
//123456
//11, java
//22, kotlin
//33, cpp
//[1, 2, 3, 4, 5, 6]
//{11=java, 22=kotlin, 33=cpp}
//// count: 특정 조건에 맞는 요소 개수 반환
//3
//// max/min : 최댓값 요소와 최솟값 요소의 반환
//6
//1
//// maxBy, minBy : 최대값과 최솟값으로 나온 요소 it에 대한 식의 결과
//33=cpp
//11=java
//// fold : 초깃값과 정해진 식에 따라 처음 요소부터 끝 요소에 적용하며 값을 생성
//25
//720
//// foldRight : fold와 같고 마지막 요소에서 처음 요소로 반대로 적용
//25
//720
//// fold : fold와 동일하지만 초깃값을 사용하지 않음
//21
//21
//// sumBy :  식에 의해 도출된 모든 요소를 합산
//6
//// all : 모든 요소가 일치해야 true
//true
//false
////any : 하나 이상의 요소가 일치하면 true
//true
//true
//// contains : 요소가 포함되어 있으면 true
//true
//true
//true
//true
//// containsAll : 모든 요소가 포함되어 있으면 true
//true
//// none : 요소가 없으면 true, 있으면 false
//false
//true
//// isEmpty / isNotEmpty : 컬렉션이 비어 있는지 아닌지 검사
//false
//true

*아래부터는 예제가 너무 많아서 함수 이름과 설명으로 대체한다.

요소의 필터와 추출

특정 요소 골라내기

filter : 식에 따라 요소를 골라냄

filterIndexed : 인덱스와 함께 추출

filterIndexedTo : 추출 후 가변형 컬렉션으로 변환

filterKeys / filterValues : Map의 키, 값에 따라 추출

filterIsInstance : 여러 자료형의 요소 중 원하는 자료형을 골라냄

특정 범위를 잘라내거나 반환하기

slice : 특정 인덱스의 요소들을 잘라서 반환

take : n개의 요소를 반환

특정 요소 제외하기

drop : 처음부터 n개의 요소를 제외한 List 반환

각 요소의 반환

각 요소는 componentN()과 대응하기 때문에 이것을 사용해 요소를 반환할 수 있다.

N은 인덱스 번호가 아닌 1부터 시작하는 요소의 순서 번호.

따라서 요소개 5개라면 1부터 5까지 가짐.

println("component1() : " + list.component1()) // 첫 번째 요소인 1 반환
// component1(): 1

합집합과 교집합

distinct : 중복 요소는 하나로 취급해 List 반환

intersect : 교집합 요소만 골라냄

요소의 매핑

map : 컬렉션에 주어진 식을 적용해 새로운 컬렉션 반환

mapIndexed : 컬렉션에 인덱스를 포함하고 주어진 식을 적용해 새로운 컬렉션 반환

mapNotNull : null을 제외하고 식을 적용해 새로운 컬렉션 반환

flatMap : 각요소에 식을 적용한 후 다시 합쳐 새로운 컬렉션을 반환

groupBy : 주어진 함수의 결과에 따라 그룹화하여 map으로 반환

요소 처리와 검색

elementAt : 인덱스에 해당하는 요소 반환

elementAtOrElse : 인덱스를 벗어나는 경우 식에 따라 결과 반환

elementAtOrNull : 인덱스를 벗어나는 경우 null 반환

 

first : 식에 일치하는 첫 요소 반환

last : 식에 일치하는 마지막 요소 반환

firstOrNull : 식에 일치하지 않는 경우 null 반환

lastOrNull : 식에 일치하지 않는 경우 null 반환

 

indexOf : 주어진 요소에 일치하는 첫 인덱스 반환

indexOfFirst : 람다식에 일치하는 첫 요소의 인덱스 반환, 없으면 -1

lastIndexOf : 주어진 요소에 일치하는 가장 마지막 인덱스 반환

indexOfLast : 람다식에 일치하는 마지막 요소의 인덱스 반환, 없으면 -1

 

single : 람다식에 일치하는 요소 하나 반환

 

binarySearch : 요소에 대해 이진 탐색 후 인덱스 반환

find : 조건식을 만족하는 첫 번째 검색된 요소 반환, 없으면 null

컬렉션의 분리와 병합

union : 두 List를 합침(중복 요소는 하나만)

plus : 두 List를 합침(중복 요소 포함), + 연산자와 같음

 

partition : 주어진 식에 따라 2개의 컬렉션으로 분리해 Pair로 반환

 

zip : 동일 인덱스끼리 Pair를 만들어 반환

순서와 정렬

reversed : 뒤집힌 순서로 컬렉션 반환

sorted : 요소를 정렬한 후 정렬된 컬렉션 반환

sortedDescending : 내림차순 정렬

sortedBy : 특정 비교식에 의해 정렬된 컬렉션 반환