[Kotlin] 코틀린 스트림 함수 (map, flatMap, groupBy, filter, take, drop, first, distinct, zip, joinToString, count, any, none, max, min, average)

안녕하세요 YTS 입니다. 오늘은 코틀린의 스트림 함수에 대해 적어보려합니다.

스트림 함수

 map() : 변환

  map()은 컬랙션 내 인자를 변환하여 반환할 때 사용됩니다.

class Map {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun map() {
        animals.map { animal -> "동물의 이름은 ? = " + animal }.forEach { println(it) }
    }
}

 mapIndexed() : 변환

 

 mapIndexed()는 컬랙션에 포함된 인자의 인덱스 값을 변환하여 사용할 수 있습니다.

class MapIndexed {
    val numbers = 0..10

    fun mapIndexed() {
        numbers.mapIndexed { index, number -> index * number }.forEach { println(it) }
    }
}

 mapNotNull() : 변환

 

 mapIndexed()는 컬랙션에 포함된 인자의 인덱스 값을 변환하여 사용할 수 있습니다.

class MapNotNull {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun mapNotNull() {
        animals.mapNotNull { animal -> if (animal.length > 2) animal else null }.forEach { println(it) }
        //사자는 글자의 갯수가 2이므로 null 로 반환이 되므로 호랑이, 코끼리만 출력이 됩니다.
    }
}

 flatMap() : 변환

 

 faltMap()은 map()함수와 비슷하지만 다른부분이 변환함수의 반환형이 Interable입니다. 즉 하나의 인자에서 여러개의 인자로 매핑이 필요할때 사용합니다.

class FlatMap {
    val numbers = 0..10

    fun flatMap() {
        numbers.flatMap { number -> 1..number }.forEach { println("$it") }
    }
}

 

 groupBy() : 변환

 

  groupBy()는 컬렉션 인자들을 기준에 따라 분류하고 각 리스트를 포함한 맵형태로 결과를 반환합니다.

class GroupBy {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun groupBy() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            animals.groupBy { animal -> if (animal.length > 2) "One" else "Two" }
                .forEach { key, animals -> println("key = $key animals = $animals") }
        }
    }
}

 filter() : 필터

 

  filter()는 리스트내에 인자들 중 조건에 일치하는 인자만 필터링합니다.

class Filter {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun filter() {
        animals.filter { animal -> animal.length > 2 }.forEach { println(it) }
    }
}

 take() : 필터

 

  take() 함수의 인자로 받은 개수만큼만을 리스트로 반환합니다.

class Take {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun take() {
        animals.take(1).forEach { println(it) }
        animals.takeLast(1).forEach { println(it) }

        animals.takeWhile { animal -> animal.length > 2 }.forEach { println(it) }
        animals.takeLastWhile { animal -> animal.length > 2 }.forEach { println(it) }
    }
}

 drop() : 필터

 

  drop()은 take() 함수와 반대로 조건을 만족하는  항목을 제외한 리스트를 반환합니다.

class Drop {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun drop() {
        animals.drop(1).forEach { println(it) }
        animals.dropLast(1).forEach { println(it) }

        animals.dropWhile { animal -> animal.length > 2 }.forEach { println(it) }
        animals.dropLastWhile { animal -> animal.length > 2 }.forEach { println(it) }
    }
}

 first(), last() : 필터

 

  first()함수는 컬랙션내에 첫번째 아이템을 반환합니다. 만약 해당 조건의 아이템이 존재 하지 않는다면 NoSuchElementException을 발생시킵니다. Null을 반환하기 위해서는 firstOrNull() 함수를 이용하여야 합니다.

마찬가지로 last()는 마지막 아이템을 반환시키며 firstOrNull()과 유사한 lastOrNull()함수가 존재합니다.

class First {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun first() {
        animals.first().forEach { println(it) }
        animals.firstOrNull()?.forEach { println(it) }

        animals.last().forEach { println(it) }
        animals.lastOrNull()?.forEach { println(it) }
    }
}

 distinct() : 필터

 

  distinct() 함수는 컬랙션 내에서 중복된 항목을 제외하고 컬랙션을 반환합니다. 중복여부는 equals()로 판단하며 distinctBy()를 사용하여 중복여부를 판단을 설정 할 수 있습니다.

class Distinct {
    val animals = listOf("사자", "호랑이", "코끼리", "사자", "호랑이")

    fun distinct() {
        animals.distinct().forEach { println(it) }
        animals.distinctBy { animal -> animal.length }.forEach { println(it) }
    }
}

 zip() : 조합

 

  zip() 함수는 두 컬랙션의 자료들을 조합하여 새로운 자료를 만들 때 사용합니다. 두 컬렉션 간 자료의 갯수가 달라도 되고 더 적은 갯수에 컬랙션쪽으로 따라 갑니다. 조합된 결과는 Pair로 만들어주며, 원할 경우 규칙을 정의 할 수 있습니다.

class Zip {
        val animals = listOf("사자", "호랑이", "코끼리")
        val animalNames = listOf("자이", "랑이", "끼리")

        fun zip() {
            animals.zip(animalNames).forEach { pair -> println("${pair.first} : ${pair.second}") }
            // 사자 : 자이
            // 호랑이 : 랑이
            // 코끼리 : 끼리

            animals.zip(animalNames) { animals, animalsNames -> "$animals : $animalsNames" }.forEach { println(it) }
            // 사자 : 자이
            // 호랑이 : 랑이
            // 코끼리 : 끼리
        }
}

 joinToString() : 조합

 

  joinToString() 함수는 컬랙션 자료를 하나의 문자열로 반환 합니다. 또한 반환문자를 구성할 수 있습니다. 반환 문자열의 대한 내용은 레퍼런스 문서를 참조 하세요. 

 https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/join-to-string.html

class JoinToString {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun joinToString() {
        println(animals.joinToString())
        //사자, 호랑이, 코끼리
    }
}

 count() : 합계

 

  count() 함수는 컬랙션 내 포함된 자료의 개수를 반환하며 조건식을 추가할 수 있습니다.

class Count {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun count() {
        println(animals.count())
        println(animals.count { animal -> animal.length > 2 })
    }
}

 any(), none() : 기타

  any() 함수는 컬랙션내에 자료가 존재하면 true, 아니면 false 를 반환합니다. 또한 조건식을 전달하여 판단 할 수 있습니다.

none()은 any()와 반대 작업을 수행 합니다.

class any {
    val animals = listOf("사자", "호랑이", "코끼리")

    fun any() {
        println(animals.any())
        println(animals.any { animal -> animal.length > 2 })
        println(animals.none())
        println(animals.none { animal -> animal.length > 2 })
    }
}

 max(), min(), average() : 기타

  max()함수는 컬랙션내에 최댓값, min()은 최솟값 average()함수는 리스트에 평균값을 반환합니다.

class maxMinAverage {
    val numbers = listOf(1, 2, 3)

    fun any() {
        println(numbers.max())
        println(numbers.min())
        println(numbers.average())
    }
}