Kotlin - 컬렉션의 확장 함수

# 컬렉션의 연산

package chap02.section1


/* 컬렉션의 연산 */




fun main() {

    val list1 : List<String> = listOf("one","two","three")
    val list2 : List<Int> = listOf(1,3,4)
    val map1 = mapOf("hi" to 1, "hello" to 2, "Goodbye" to 3)

    println(list1 + "four")                             // 문자열 값 추가
    println(list2 + 1)                                  // 정수형 값 추가
    println(list2 + listOf(5,6,7))                      // 리스트 병합
    println(list2 - 1)                                  // 값 제거
    println(list2 - listOf(3,4,5))                      // 일치하는 요소 제거
    println(map1 + Pair("Bye",4))                       // Pair()를 사용한 Map의 요소 추가
    println(map1 - "hello")                             // 일치하는 값의 제거
    println(map1 + mapOf("Apple" to 4, "Orange" to 5))  // 두 Map의 병합
    println(map1 - listOf("hi","hello"))                // List에 일치하는 값을 Map에서 제거





}

# 컬렉션의 연산2

package chap02.section1


/* 컬렉션의 연산 */




fun main() {

    val list = listOf(1,2,3,4,5,6)
    val listPair = listOf(Pair("A",300),Pair("B",200),Pair("C",100))
    val map = mapOf(11 to "Java", 22 to "Kotlin", 33 to "C++")

    // 요소의 순환
    list.forEach { println("$it") }
    list.forEachIndexed{index,value -> println("index[$index] = $value")}

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

    // 요소의 개수 반환하기
    println(list.count{it % 2 == 0})        // 람다식 조건 : 짝수의 요소들의 개수 반환(2,4,6) = 3개

    // 최댓값과 최솟값의 요소 반환하기
    println(list.max())
    println(list.min())

    println("maxBy : " + map.maxBy { it.key })
    println("minBy : " + map.minBy { it.key })

    // 각 요소에 정해진 식 사용하기
    // fold : 초깃값과 정해진 식에 따라 처음 요소부터 끝 요소에 적용하며 값을 생성
    println(list.fold(4) {total, next -> total + next})             // 4+1+2+3+4+5+6 = 25
    println(list.fold(1) {total, next -> total * next})             // 1*1*2*3*4*5*6 = 720

    // foldRight : fold와 같고 마지막 요소에서 처음 요소로 반대로 적용
    println(list.foldRight(4) {total, next -> total + next})        // 4+6+5+4+3+2+1 = 25
    println(list.foldRight(1) {total, next -> total * next})        // 1*6*5*4*3*2*1 = 720

    // reduce : fold와 동일하지만 초깃값을 사용하지 않음
    println(list.reduce {total, next -> total + next})                    // 1+2+3+4+5+6 = 21
    println(list.reduceRight {total,next -> total + next})                // 6+5+4+3+2+1 = 21

    // 모든 요소 합산하기
    println(listPair.sumBy { it.second })






}

 

# 컬렉션의 연산3

 

package chap02.section1


/* 컬렉션의 연산 */




fun main() {

    val list = listOf(1,2,3,4,5,6)
    val listPair = listOf(Pair("A",300),Pair("B",200),Pair("C",100))
    val map = mapOf(11 to "Java", 22 to "Kotlin", 33 to "C++")

    // 요소의 일치 여부 확인하기 (all,any)
    println(list.all { it < 10 })               // 모든 요소가 10보다 작으면 true
    println(list.all { it % 2 == 0 })           // 모든 요소가 짝수으면 true
    println(list.any {it % 2 == 0})             // 최소한 하나의 요소가 짝수이면 true
    println(list.any {it > 10})                 // 최소한 하나의 요소가 10보다 크면 true

    // 특정 요소의 포함 및 존재 여부 검사하기
    println("contains : " + list.contains(2))   // 2가 포함되어 있으면 true
    println(2 in list)                          // 2가 포함되어 있으면 true
    println(map.contains(11))                   // 11(key)가 포함되어 있으면 true
    println(11 in map)                          // 11(key)가 포함되어 있으면 true
    println("containsAll: " + list.containsAll(listOf(1,2,3,100)))      // containsAll : 모든 요소가 포함되어 있으면 true

    println("none : " + list.none())            // 요소가 없으면 true
    println("none : " + list.none {it > 6})     // 6이상인 요소가 없으면 true

    println(list.isEmpty())                     // 컬렉션이 비어 있는지 검사
    println(list.isNotEmpty())                  // 컬렉션이 안 비어 있는지 검사
    

}

# 컬렉션의 연산4

package chap02.section1


/* 요소의 필터와 추출 */




fun main() {

    val list = listOf(1,2,3,4,5,6)
    val listMixed = listOf(1,"Hello",3,"World",5,'A')
    val listWithNull = listOf(1,null,3,null,5,6)
    val listRepeated = listOf(2,2,3,4,5,5,6)
    val map = mapOf(11 to "Java", 22 to "Kotlin", 33 to "C++")

    println(list.filter { it % 2 == 0 })                        // 짝수인 것만 골라내기
    println(list.filterNot { it % 2 == 0 })                     // 짝수가 아닌 것만 골라내기
    println(listWithNull.filterNotNull())                       // null 제외


    // filterIndexed : 인덱스와 함께 추출
    println("filterIndexed: " + list.filterIndexed{idx,value -> idx != 1 && value % 2 == 0})
    // filterIndexedTo : 추출 후 가변형 컬렉션으로 변환
    val mutList = list.filterIndexedTo(mutableListOf()) {idx,value -> idx != 1 && value % 2 == 0}
    println("filterIndexedTo : $mutList")

    // filterKeys, filterValues : Map의 키,값에 따라 추출
    println("filterKeys : " + map.filterKeys { it != 11 })              // key값이 11인 것 제외
    println("filterValues: " + map.filterValues { it == "Java" })       // Value값이 Java인 것만

    // filterInstance : 여러 자료형의 요소 중 원하는 자료형을 골라냄
    println("filterInstance : " + listMixed.filterIsInstance<String>())

    // slice : 특정 인덱스의 요소들을 잘라서 반환하기(list)
    println("slice : " + list.slice(listOf(0,1,2)))                     // 0~2번의 인덱스의 값을 반환

    // take : n개의 요소를 반환(list)
    println(list.take(2))                    // 앞의 2개의 요소 반환
    println(list.takeLast(2))                // 마지막의 2개의 요소 반환
    println(list.takeWhile { it < 3 })          // 요소가 3보다 작은 것들 반환

    // drop : n개의 요소를 제외하고 반환(list)
    println(list.drop(3))                   // 앞의 3개의 요소 제외하고 반환
    println(list.dropWhile { it < 3 })         // 3 미만을 제외하고 반환
    println(list.dropLastWhile { it > 3 })      // 3 초과를 제외하고 반환

    /* 각 요소의 반환 : componenetN()
      각 요소는 componentN()과 대응하기 때문에 이것을 사용해 요소를 반환할 수 있다.
      단, N은 인덱스 번호가 아닌 1부터 시작한다.
     */
    println("component1() : ${list.component1()}")


    // 합집합과 교집합
    // distinct : 중복 요소는 하나로 취급해 List 반환
    println("distinct : ${listRepeated.distinct()}")

    // intersect : 교집합 요소만 골라냄
    println("intersect: ${list.intersect(listOf(5,6,7,8))}")



}

# 요소의 매핑

package chap02.section1


/* 요소의 매핑 */

fun main() {

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


    // map : 컬렉션에 주어진 식을 적용해 새로운 컬렉션 반환
    println(list.map { it * 2 })

    // mapIndexed : 컬렉션에 인덱스를 포함하고 주어진 식을 적용해 새로운 컬렉션 반환
    val mapIndexed = list.mapIndexed {index, it -> index * it}
    println(mapIndexed)

    // mapNotNull : null을 제외하고 식을 적용해 새로운 컬렉션 반환
    println(listWithNull.mapNotNull { it?.times(2) })

    // flatMap : 각 요소에 식을 적용한 후 다시 합쳐 새로운 컬렉션을 반환
    println(list.flatMap { listOf(it,'A') })
    val result = listOf("abc","12").flatMap { it.toList() }
    println(result)

    // groupBy : 주어진 함수의 결과에 따라 그룹화하여 map으로 반환
    val grpMap = list.groupBy { if (it % 2 == 0) "even" else "odd" }
    println(grpMap)


}

# 요소처리와 검색

package chap02.section1


/* 요소처리와 검색 */

fun main() {

    val list = listOf(1,2,3,4,5,6)
    val listPair = listOf(Pair("A",300),Pair("B",200),Pair("C",100),Pair("D",200))
    val listRepeated = listOf(2,2,3,4,5,5,6)

    // elementAt : 인덱스에 해당하는 요소 반환
    println("elementAt :" + list.elementAt(1))
    // elementAtOrElse : 인덱스를 벗어나는 경우 식에 따라 결과 반환
    println("elementAtOrElse : " + list.elementAtOrElse(10) { 2 * it })
    // elementAtOrNull : 인덱스를 벗어나는 경우 null 반환
    println("elementAtOrNull : " + list.elementAtOrNull(10))

    // first : 식에 일치하는 첫 요소 반환
    println("first : " + listPair.first {it.second == 200})
    // last : 식에 일치하는 마지막 요소 반환
    println("last : " + listPair.last {it.second == 200})
    // firstOrNull : 식에 일치하지 않는 경우 null 반환(첫번째 요소)
    println("firstOrNull : " + listPair.firstOrNull{it.first == "E"})
    // lastOrNull : 식에 일치하지 않는 경우 null 반환(마지막 요소)
    println("lastOrNull : " + listPair.lastOrNull {it.first == "E"})

    // indexOf : 주어진 요소에 일치하는 첫 인덱스 반환
    println("indexOf : " + listRepeated.indexOf(5))
    // indexOfFirst : 람다식에 일치하는 첫 요소의 인덱스 반환, 없으면 -1
    println("indexOfFirst : " + list.indexOfFirst { it % 2 == 0 })
    // lastIndexOf : 주어진 요소에 일치하는 가장 마지막 인덱스 반환
    println("lastIndexOf : " + listRepeated.lastIndexOf(5))
    // indexOfLast : 람다식에 일치하는 마지막 요소의 인덱스 반환, 없으면 -1
    println("indexOfLast : " + list.indexOfLast { it % 2 == 0 })


    // single : 람다식에 일치하는 요소 하나 반환
    println("single : " + listPair.single {it.second == 100})               // 요소가 1개일 때 반환, 1개 이상이면 예외발생
    println("singleOrNull : " + listPair.singleOrNull {it.second == 500})   // 요소가 1개일 때 반환가능 아니면 null 반환


    // find : 조건식을 만족하는 첫 번째 검색된 요소 반환, 없으면 null
    println("find : " + list.find { it > 3 })









}

# 컬렉션의 분리와 병합

package chap02.section1


/* 컬렉션의 분리와 병합 */

fun main() {

    val list1 = listOf<Int>(1,2,3,4,5,6)
    val list2 = listOf(2,2,3,4,5,5,6,7)

    // union : 두 List를 합침(중복 요소는 하나만)   -> return은 Set 컬렉션으로 반환
    println("union : " + list1.union(list2))

    // plus : 두 List를 합침(중복 요소 포함)      -> return list 컬렉션으로 반환
    println("plus : " + list1.plus(list2))

    // partition : 주어진 식에 따라 2개의 컬렉션으로 분리해 Pair로 반환
    val part = list1.partition { it % 2 == 0 }
    println(part)

    // zip : 동일 인덱스끼리 Pair를 만들어 반환
    val zip1 = list1.zip(listOf(0,0,0,0,0,0))
    println(zip1)

    /* 순서와 정렬 */

    // reversed : 뒤집힌 순서로 컬렉션 반환
    val unsortedList = listOf(3,2,7,5)
    println(unsortedList.reversed())

    // sorted : 요소를 정렬한 후 정렬된 컬렉션 반환
    println(unsortedList.sorted())

    // sortedDescending : 내림차순 정렬
    println(unsortedList.sortedDescending())

    // sortedBy : 특정 비교식에 의해 정렬된 컬렉션 반환★
    println(unsortedList.sortedBy { it % 3 })
    println(unsortedList.sortedByDescending { it % 3 })


}