컬렉션 라이브러리 - swkim0128/PARA GitHub Wiki

코틀린은 강력한 컬렉션 라이브러리를 제공하며, 리스트(List), 셋(Set), 맵(Map) 등의 기본 컬렉션 타입과 다양한 확장 함수를 활용하여 편리한 데이터 처리가 가능하다.

1. 컬렉션 개요

컬렉션은 여러 개의 데이터를 저장하고 조작할 수 있는 자료구조로, 코틀린에서는 다음과 같은 기본 컬렉션이 제공된다.

컬렉션 타입 설명
List 순서가 있는 요소들의 집합 (중복 허용)
Set 순서가 없고, 중복을 허용하지 않는 집합
Map 키-값(Key-Value) 쌍을 저장하는 자료구조

코틀린의 컬렉션은 불변(Immutable)과 가변(Mutable) 두 가지 타입으로 나뉜다.

2. 리스트(List)

리스트는 순서가 있는 데이터의 집합이며, 같은 값을 여러 번 포함할 수 있다.

불변 리스트 (listOf())

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    println(numbers) // 출력: [1, 2, 3, 4, 5]
}
  • 불변 리스트는 요소를 추가하거나 삭제할 수 없다.

가변 리스트 (mutableListOf())

fun main() {
    val numbers = mutableListOf(1, 2, 3)
    numbers.add(4)
    numbers.remove(1)
    println(numbers) // 출력: [2, 3, 4]
}
  • 가변 리스트는 add(), remove() 등을 사용하여 데이터를 변경할 수 있다.

3. 셋(Set)

셋(Set)은 중복을 허용하지 않는 컬렉션이며, 원소의 순서가 중요하지 않다.

불변 셋 (setOf())

fun main() {
    val uniqueNumbers = setOf(1, 2, 2, 3, 4)
    println(uniqueNumbers) // 출력: [1, 2, 3, 4] (중복 제거)
}

가변 셋 (mutableSetOf())

fun main() {
    val uniqueNumbers = mutableSetOf(1, 2, 3)
    uniqueNumbers.add(4)
    uniqueNumbers.remove(2)
    println(uniqueNumbers) // 출력: [1, 3, 4]
}
  • add()로 요소를 추가하고, remove()로 삭제할 수 있다.

4. 맵(Map)

맵(Map)은 키(Key)와 값(Value)의 쌍으로 이루어진 컬렉션이다.

불변 맵 (mapOf())

fun main() {
    val studentGrades = mapOf("Alice" to 90, "Bob" to 85, "Charlie" to 92)
    println(studentGrades) // 출력: {Alice=90, Bob=85, Charlie=92}
}
  • mapOf()를 사용하면 불변 맵을 생성할 수 있다.

가변 맵 (mutableMapOf())

fun main() {
    val studentGrades = mutableMapOf("Alice" to 90, "Bob" to 85)
    studentGrades["Charlie"] = 92 // 새로운 값 추가
    studentGrades.remove("Bob") // 키 "Bob" 삭제
    println(studentGrades) // 출력: {Alice=90, Charlie=92}
}
  • put(), remove() 등을 활용하여 데이터를 변경할 수 있다.

5. 컬렉션 함수

코틀린 컬렉션 라이브러리는 다양한 고차 함수(Higher-Order Functions) 를 제공하여 데이터를 쉽게 변환, 필터링, 집계할 수 있다.

1) map() - 모든 요소 변환

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    val squared = numbers.map { it * it }
    println(squared) // 출력: [1, 4, 9, 16]
}
  • 리스트의 각 요소를 변환하여 새로운 리스트를 생성한다.

2) filter() - 특정 조건의 요소 선택

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println(evenNumbers) // 출력: [2, 4, 6]
}
  • 리스트에서 특정 조건을 만족하는 요소만 필터링한다.

3) forEach() - 각 요소 순회

fun main() {
    val names = listOf("Alice", "Bob", "Charlie")
    names.forEach { println(it) }
}

• 리스트의 모든 요소를 순회하며 처리할 수 있다.

4) reduce() - 리스트를 단일 값으로 축약

fun main() {
    val numbers = listOf(1, 2, 3, 4)
    val sum = numbers.reduce { acc, num -> acc + num }
    println(sum) // 출력: 10
}

• 리스트의 모든 요소를 순차적으로 누적하여 하나의 결과를 만든다.

5) groupBy() - 특정 기준으로 그룹화

fun main() {
    val words = listOf("apple", "banana", "cherry", "avocado")
    val grouped = words.groupBy { it.first() }
    println(grouped) // 출력: {a=[apple, avocado], b=[banana], c=[cherry]}
}
  • 리스트의 요소를 특정 기준에 따라 그룹으로 나눈다.

6. 시퀀스(Sequence)

코틀린에서는 시퀀스(Sequence) 를 사용하면 대량의 데이터를 처리할 때 성능을 향상시킬 수 있다. Sequence는 지연 연산(lazy evaluation) 을 사용하여 불필요한 계산을 최소화한다.

시퀀스를 활용한 성능 최적화

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)

    val result = numbers.asSequence()
        .map { it * 2 }
        .filter { it > 5 }
        .toList()

    println(result) // 출력: [6, 8, 10, 12]
}
  • asSequence()를 사용하면 불필요한 연산을 줄이고 최적화할 수 있다.

7. 컬렉션 vs 시퀀스 차이점

비교 항목 컬렉션(List, Set, Map) 시퀀스(Sequence)
평가 방식 즉시 연산 (Eager) 지연 연산 (Lazy)
성능 작은 데이터에서는 빠름 대량 데이터에서 최적화 가능
연산 방식 모든 요소를 처리 후 결과 반환 필요한 요소만 처리
예제 listOf().map().filter() asSequence().map().filter().toList()

8. 컬렉션 정리

컬렉션 타입 특징 주요 메서드
List 순서가 있는 데이터 저장, 중복 허용 listOf(), mutableListOf(), map(), filter()
Set 중복 불허, 순서 없음 setOf(), mutableSetOf(), contains(), add(), remove()
Map 키-값 형태 저장 mapOf(), mutableMapOf(), get(), put(), remove()
Sequence 지연 연산을 통한 최적화 asSequence(), map(), filter(), toList()

9. 결론

  • 코틀린 컬렉션 라이브러리는 List, Set, Map 등의 기본 컬렉션을 제공하며, 불변과 가변 컬렉션을 지원한다.
  • map(), filter(), reduce() 등의 확장 함수를 활용하면 데이터를 쉽게 조작할 수 있다.
  • 시퀀스(Sequence) 를 활용하면 대량의 데이터 처리 성능을 최적화할 수 있다.

컬렉션 라이브러리를 잘 활용하면 더 효율적이고 가독성 높은 코드를 작성할 수 있다.

⚠️ **GitHub.com Fallback** ⚠️