[Kotlin & Spring] 01. Kotlin 컬렉션

[tonykang22]

01. Kotlin 컬렉션

컬렉션 타입

컬렉션에 대해

• 코틀린 표준 라이브러리는 기본 컬렉션 타입인 List, Set, Map 을 제공한다.
• 컬렉션은 두 가지 종류로 나뉜다.
  • 불변 컬렉션(Immutable) : 읽기 전용 컬렉션
  • 가변 컬렉션(Mutable) : 삽입, 수정, 삭제와 같은 쓰기 작업이 가능한 컬렉션
• 컬렉션 다이어그램

컬렉션 생성 방법

• 컬렉션을 생성할 때 가장 일반적인 방법은 표준 라이브러리 함수를 사용하는 것이다.
• Immutable 리스트 생성

val currencyList: List<String> = listOf("달러", "유료", "원 ")

• Mutable 리스트 생성

val mutableCurrencyList = mutableListOf<String>()
mutableCurrentList.add("달러")
mutableCurrentList.add("유로")
mutableCurrentList.add("원")

• apply 함수를 사용하면 가독성이 좋아진다.

val mutableCurrencyList = mutableListOf<String>().apply {
    add("달러")
    add("유로")
    add("원")
}

• Immutable Set 생성

val numberSet = setOf(1, 2, 3, 4)

• Mutable Set 생성

val mutableSet = mutableSetOf<Int>()

• Immutable Map 생성
  • to라는 중위 함수로 Key-Value 구조를 전달한다.

val numberMap = mapOf("one" to 1, "two" to 2)

• Mutable Map 생성

val mutableNumberMap = mutableMapOf<String, Int>()
mutableNumberMap["one"] = 1
mutableNumberMap["two"] = 2
mutableNumberMap["three"] = 3

• 컬렉션 빌더를 사용해 컬렉션을 생성할 수 있다.
  • buildList, buildSet, buildMap 3종류 제공
• build 내부에서는 Mutable하고 반환시에는 Immutable이다.

val numberList: List<Int> = buildList {
    // buildMap 내부에서는 MutableMap
    add(1)
    add(2)
    add(3)
}

• 특정 구현체를 사용하고 싶은 경우 구현체의 생성자를 사용한다.

val linkedList = LinkedList<Int>().apply {
    add(1)
    add(2)
    add(3)
}

컬렉션 반복하기

• 코틀린의 컬렉션은 Iterable의 구현체이므로 순차적 반복이 가능하다.

val iterator = currencyList.iterator()
while (iterator.hasNext()) {
    println(iterator.next())
}

• 자바에서는 forEach를 사용해 Iterable을 구현한 컬렉션을 반복할 수 있다.
• 코틀린은 for loop를 사용하면 암시적으로 Iterator를 사용하기 때문에 조금 더 쉽게 반복할 수 있다.

for (currency in currencyList) {
    print(currency)
}

• 또한 코틀린 표준 라이브러리에는 컬렉션 사용 시 자주 사용되는 패턴인 forEach, map, filter와 같은 유용한 인라인 함수를 제공한다.

currency.forEach {
    println(it)
}

• for loop를 map으로 변환하기 전

val lowerList = listOf("a", "b", "c", "d")
val upperList = mutableListOf<String>()

for (lowerCase in lowerList) {
    upperList.add(lowerCase.upperCase())
}

println(upperList)
// [A, B, C, D]

• for loop를 map으로 변환 후

val upperList = lowerList.map { it.upperCase() }
println(upperList)
// [A, B, C, D]

• for loop를 filter로 변환하기 전

val filteredList = mutableListOf<String>()
for (upperCase in upperList) {
    if (upperCase == "A" || upperCase == "C") {
        filteredList.add(upperCase)
    }
}
println(filteredList)
// [A, C]

• for loop를 filter로 변환 후

val filteredList = upperList.filter { it == "A" || it == "C" }
println(filteredList)
// [A, C]

• 자바8의 스트림과 비교
  • 자바8 스트림은 중간 연산자(map, filter, flatMap 등)만 사용했을 때는 아무런 동작도 하지 않는다.
  • 값을 얻고 싶으면 최종 연산자(Terminal operator)를 사용해야한다.

val filteredList = upperList.stream().filter { it == "A" || it == "C" }

println(filteredList)
// java.util.stream.ReferencePipeline$2@77b52d12

val filteredList = upperList.stream()
            .filter { it == "A" || it == "C" }
            .collect(Collectors.toList())

println(filteredList)
// [A, C]

• 코틀린에서는 sequence를 사용해 자바8 스트림과 같이 Lazy하게 동작시킬 수 있다.

val filteredList = upperList
            .asSequence()
            .filter { it == "A" || it == "C" }

println(filteredList)
// kotlin.sequences.FilteringSequence@7f560810

• Sequence API도 최종 연산자를 사용해야 중간 연산자가 동작한다.

val filteredList = upperList
            .asSequence()
            .filter { it == "A" || it == "C" }
            .toList()

println(filteredList)
// [A, C]

추가

• 일반적으로 인라인 함수는 각각 함수가 동작할 때마다 조건에 맞는 컬렉션을 생성한다.
• Sequence API는 각각의 함수가 동작할 때 sequence를 생성하고 최종 연산자를 호출할 때 1개의 컬렉션을 생성한다.
• 벤치마크 상으로 일반적으로는 인라인 함수가 빠르기 때문에 인라인 함수를 쓰고 대량의 데이터를 다룰 때는 sequence API 사용을 추천한다.