Kotlin/collection functional api - map, filter, flatten type api

app/src/test/java/com/example/learningtest/collection/functional/FilteringTest.kt

@@ -0,0 +1,149 @@
+package com.example.learningtest.collection.functional
+
+import io.kotest.core.spec.style.FreeSpec
+import io.kotest.matchers.shouldBe
+
+class FilteringTest : FreeSpec({
+    "List Filter Api" - {
+        "filter - 조건을 만족하는 것만 남기기" {
+            val numbers: List<Int> = listOf(1, 2, 3, 4, 5, 6)
+            numbers.filter { it % 2 == 0 } shouldBe listOf<Int>(2, 4, 6)
+        }
+
+        "filterNot - 조건을 만족하지 않는 요소만 남기기" {
+            val words: List<String> = listOf("a", "be", "cat")
+            words.filterNot { it.length > 1 } shouldBe listOf<String>("a")
+        }
+
+        "filterIndexed - 인덱스와 함께 필터링" {
+            val words: List<String> = listOf("zero", "one", "two", "three")
+            val result = words.filterIndexed { index, _ -> index % 2 == 0 }
+            result shouldBe listOf<String>("zero", "two")
+        }
+
+        "take - 앞에서부터 N개 가져오기" {
+            val numbers: List<Int> = listOf(0, 1, 2, 3, 4)
+            numbers.take(2) shouldBe listOf<Int>(0, 1)
+        }
+
+        "drop - 앞에서부터 N 개 버리고 나머지 가져오기" {
+            val numbers: List<Int> = listOf(0, 1, 2, 3, 4)
+            numbers.drop(2) shouldBe listOf<Int>(2, 3, 4)
+        }
+
+        "takeWhile - 앞에서부터 조건이 거짓이기 전까지 가져오기(거짓이되면 순회 중지)" {
+            val numbers: List<Int> = listOf(1, 2, 3, 0, 4)
+            numbers.takeWhile { number -> number > 0 } shouldBe listOf<Int>(1, 2, 3)
+        }
+
+        "dropWhile - 앞에서부터 조건이 참이기 전까지 버리고 나머지 가져오기(참이 되면 순회 중지)" {
+            val numbers: List<Int> = listOf(1, 2, 3, 0, 4)
+            numbers.dropWhile { it > 0 } shouldBe listOf<Int>(0, 4)
+        }
+
+        "filterTo - 필터링 결과를 기존 컬렉션에 추가" {
+            val target: MutableList<Int> = mutableListOf(0, 9)
+            val source: List<Int> = listOf(1, 2, 3, 4)
+            source.filterTo(target) { it > 2 }
+
+            target shouldBe listOf<Int>(0, 9, 3, 4)
+        }
+
+        "filterIndexedTo - 인덱스와 함께 필터링 결과를 기존 컬렉션에 추가" {
+            val target: MutableList<String> = mutableListOf("hello", "world")
+            val source: List<String> = listOf("a", "b", "c", "d")
+            source.filterIndexedTo(target) { index, _ -> index % 2 == 0 }
+
+            target shouldBe listOf<String>("hello", "world", "a", "c")
+        }
+
+        "filterNotTo - 조건을 만족하지 않은 것만 필터링해서 기존 컬렉션에 추가" {
+            val target: MutableList<Int> = mutableListOf(3, 3)
+            val source: List<Int> = listOf(1, 2, 3, 4)
+            source.filterNotTo(target) { it % 2 == 0 }
+
+            target shouldBe listOf<Int>(3, 3, 1, 3)
+        }
+
+        "filterIsInstance - 타입 필터링" {
+            val list: List<Any> = listOf(1, "a", 2L, 'b', "c")
+            list.filterIsInstance<String>() shouldBe listOf("a", "c")
+        }
+
+        "filterIsInstanceTo - 타입 필터링 후 다른 컬렉션에 저장" {
+            val target: MutableList<String> = mutableListOf("d")
+            val source: List<Any> = listOf("a", 1, 'b', 2L, "c")
+
+            source.filterIsInstanceTo(target) shouldBe listOf<String>("d", "a", "c")
+        }
+
+        "distinct - 중복 제거" {
+            val list: List<Int> = listOf(1, 2, 3, 1, 2)
+            list.distinct() shouldBe listOf<Int>(1, 2, 3)
+        }
+
+        "distinctBy - 조건에 따라 중복 제거 (대표 요소 하나만 남김)" {
+            val list: List<String> = listOf("aaa", "bbb", "ccc", "aa", "bb", "cc", "a", "b", "c")
+            list.distinctBy { it.length } shouldBe listOf<String>("aaa", "aa", "a")
+        }
+
+        "partition - 조건에 따라 두 그룹으로 나누기" {
+            val list: List<Int> = listOf(1, 2, 3, 4, 5)
+            val (even: List<Int>, odd: List<Int>) = list.partition { it % 2 == 0 }
+
+            even shouldBe listOf(2, 4)
+            odd shouldBe listOf(1, 3, 5)
+        }
+    }
+
+    "Map Filter Api" - {
+        val map: Map<String, Int> =
+            mapOf(
+                "a" to 1,
+                "b" to 2,
+                "c" to 3,
+                "d" to 4,
+            )
+
+        "filter - (key, value) 쌍으로 필터링" {
+            // requires a pair of parentheses around the key and value in the lambda block.
+            val result: Map<String, Int> =
+                map.filter { (key, value) -> key in listOf<String>("a", "c") && value % 2 == 1 }
+
+            result shouldBe mapOf<String, Int>("a" to 1, "c" to 3)
+        }
+
+        "filterKeys - key 기준 필터링" {
+            val result: Map<String, Int> = map.filterKeys { it > "b" }
+            result shouldBe mapOf<String, Int>("c" to 3, "d" to 4)
+        }
+
+        "filterValues - value 기준 필터링" {
+            val result: Map<String, Int> = map.filterValues { it % 2 == 0 }
+            result shouldBe mapOf<String, Int>("b" to 2, "d" to 4)
+        }
+
+        "filterNot - 조건을 만족하지 않는 (key, value) 필터링" {
+            val result: Map<String, Int> = map.filterNot { (_, value) -> value > 2 }
+            result shouldBe mapOf("a" to 1, "b" to 2)
+        }
+
+        "filterTo - 조건을 만족하는 항목을 다른 MutableMap에 추가" {
+            val source: Map<String, Int> = mapOf("one" to 1, "two" to 2, "three" to 3)
+            val target: MutableMap<String, Int> = mutableMapOf()
+
+            source.filterTo(target) { (_, v) -> v % 2 == 1 }
+
+            target shouldBe mapOf("one" to 1, "three" to 3)
+        }
+
+        "filterNotTo - 조건을 만족하지 않는 항목을 target에 추가" {
+            val source: Map<String, Int> = mapOf("a" to 1, "b" to 2, "c" to 3)
+            val result: MutableMap<String, Int> = mutableMapOf()
+
+            source.filterNotTo(result) { (_, v) -> v > 1 }
+
+            result shouldBe mapOf("a" to 1)
+        }
+    }
+})

app/src/test/java/com/example/learningtest/collection/functional/FlatteningTest.kt

@@ -0,0 +1,200 @@
+package com.example.learningtest.collection.functional
+
+import io.kotest.core.spec.style.FreeSpec
+import io.kotest.matchers.shouldBe
+
+class FlatteningTest : FreeSpec({
+    "List 의 flattening" - {
+        "flatten - 중첩된 리스트를 평탄화" {
+            val nested: List<List<Int>> =
+                listOf(
+                    listOf(1, 2),
+                    listOf(3, 4),
+                )
+
+            nested.flatten() shouldBe listOf(1, 2, 3, 4)
+        }
+
+        "flatten - 깊이 n 번의 중첩은 n 번의 flatten 으로 평탄화" {
+            val nested: List<List<List<Int>>> =
+                listOf(
+                    listOf(
+                        listOf(1, 2),
+                        listOf(11, 22),
+                    ),
+                    listOf(
+                        listOf(3, 4),
+                        listOf(33, 44),
+                    ),
+                )
+
+            val onceFlattened: List<List<Int>> = nested.flatten()
+            val twiceFlattened: List<Int> = onceFlattened.flatten()
+
+            onceFlattened shouldBe
+                listOf(
+                    listOf(1, 2),
+                    listOf(11, 22),
+                    listOf(3, 4),
+                    listOf(33, 44),
+                )
+            twiceFlattened shouldBe listOf(1, 2, 11, 22, 3, 4, 33, 44)
+        }
+
+        "flatMap - 각 요소를 여러 개로 펼친 후 평탄화" {
+            val nested: List<List<Int>> =
+                listOf(
+                    listOf(1, 2),
+                    listOf(3, 4),
+                )
+
+            val flattened: List<Int> = nested.flatMap { it }
+            flattened shouldBe listOf(1, 2, 3, 4)
+        }
+
+        "flatMapIndexed - 인덱스와 함께 각 요소를 여러 개로 펼친 후 평탄화" {
+            val nested: List<List<Int>> =
+                listOf(
+                    listOf(1, 2),
+                    listOf(3, 4),
+                )
+
+            val flattened: List<Int> =
+                nested.flatMapIndexed { index, list ->
+                    list.map { value -> index * value }
+                }
+
+            flattened shouldBe listOf(0, 0, 3, 4)
+        }
+
+        "flatMapTo - 중첩된 리스트를 평탄화해서 기존 컬렉션에 추가" {
+            val source: List<List<Int>> =
+                listOf(
+                    listOf(1, 2),
+                    listOf(3, 4),
+                )
+            val destination: MutableList<Int> = mutableListOf(0)
+            source.flatMapTo(destination) { it }
+
+            destination shouldBe listOf(0, 1, 2, 3, 4)
+        }
+
+        "flatMapIndexed - 인덱스와 함께 각 요소를 여러 개로 펼친 후 평탄화해서 기존 컬렉션에 추가" {
+            val nested: List<List<Int>> =
+                listOf(
+                    listOf(1, 2),
+                    listOf(3, 4),
+                )
+            val destination: MutableList<Int> = mutableListOf(0, 1, 2)
+            nested.flatMapIndexedTo(destination) { index, list ->
+                list.map { value -> value * 2 }
+            }
+
+            destination shouldBe listOf(0, 1, 2, 2, 4, 6, 8)
+        }
+    }
+
+    "Map 의 flattening" - {
+        "flatMap - Map<K, List<V>> 구조를 평탄화" {
+            val map: Map<String, List<Int>> =
+                mapOf(
+                    "a" to listOf(1, 2),
+                    "b" to listOf(3),
+                )
+
+            val result: List<String> =
+                map.flatMap { (key, numbers) ->
+                    numbers.map { number -> "$key:$number" }
+                }
+
+            result shouldBe listOf<String>("a:1", "a:2", "b:3")
+        }
+
+        "flatMap - 사실 flatMap 의 람다 파라미터의 리턴 타입이 Iterable 타입이기만 하면 된다." {
+            val map: Map<String, Int> =
+                mapOf(
+                    "a" to 1,
+                    "b" to 2,
+                    "c" to 3,
+                )
+
+            val result: List<Int> =
+                map.flatMap { (_, number) ->
+                    List(number) { number }
+                }
+
+            result shouldBe listOf<Int>(1, 2, 2, 3, 3, 3)
+        }
+
+        "toList - Map<K, V> 를 List<Pair<K, V>> 로 변환" {
+            val map: Map<String, List<Int>> =
+                mapOf(
+                    "a" to listOf(1, 2),
+                    "b" to listOf(3),
+                )
+
+            val toList: List<Pair<String, List<Int>>> = map.toList()
+
+            toList shouldBe
+                listOf<Pair<String, List<Int>>>(
+                    "a" to listOf<Int>(1, 2),
+                    "b" to listOf<Int>(3),
+                )
+        }
+
+        "flatMapValues 메서드는 따로 없어서 Map<K, V>.values.flatten 사용" {
+            val map: Map<String, List<Int>> =
+                mapOf(
+                    "a" to listOf(1, 2),
+                    "b" to listOf(3),
+                )
+
+            val result: List<Int> = map.values.flatten()
+            result shouldBe listOf<Int>(1, 2, 3)
+        }
+
+        "flatPairValues 메서드는 따로 없어서 아래처럼 재구성 필요" {
+            val map: Map<String, List<Int>> =
+                mapOf(
+                    "a" to listOf(1, 2),
+                    "b" to listOf(3),
+                )
+
+            val result1: List<Pair<String, Int>> =
+                map.flatMap { entry ->
+                    entry.value.map { value -> entry.key to value }
+                }
+
+            val result2: List<Pair<String, Int>> =
+                map.entries.flatMap { entry ->
+                    entry.value.map { value -> entry.key to value }
+                }
+
+            result1 shouldBe
+                listOf<Pair<String, Int>>(
+                    "a" to 1,
+                    "a" to 2,
+                    "b" to 3,
+                )
+            result1 shouldBe result2
+        }
+
+        "Map<String, String>.toList(). 은 단순 List<Pair<Key, Value>> 리스트로 변환" {
+            val map: Map<String, String> =
+                mapOf(
+                    "a" to "1",
+                    "b" to "2",
+                    "c" to "3",
+                )
+
+            val flatList: List<Pair<String, String>> = map.toList()
+
+            flatList shouldBe
+                listOf<Pair<String, String>>(
+                    "a" to "1",
+                    "b" to "2",
+                    "c" to "3",
+                )
+        }
+    }
+})