[ Kotlin ] 컬렉션 클래스

List

설명

• 데이터를 코드에 지정한 순서대로 저장
• 데이터를 모아 관리하는 collection 클래스에서 상속받은 클래스 중 가장 단순한 형태
• 여러 개의 데이터를 원하는 순서대로 넣어 관리하는 형태
• List<T>
  • 생성 시에 넣은 객체를 대체, 추가, 삭제 불가능
  • listOf( … )
• MutableList<T>
  • 생성 시에 넣은 객체를 대체, 추가, 삭제 가능
  • mutableListOf( … )
• 추가
  • add( 데이터 )
  • add( 인덱스, 데이터 )
• 삭제
  • remove( 데이터 )
  • removeAt( 인덱스 )
• 무작위 섞기
  • shuffle()
• 정렬
  • sort()
• 대체
  • list[ 인덱스 ] = 데이터

 

코드

fun main() {
    var _List = listOf("사과", "딸기", "배")
    println(_List)

    println()

    var _MutableList = mutableListOf(6, 3, 1)
    println(_MutableList)

    _MutableList.add(4)
    println(_MutableList)

    _MutableList.add(2, 8)
    println(_MutableList)

    _MutableList.removeAt(1)
    println(_MutableList)

    _MutableList.shuffle()
    println(_MutableList)

    _MutableList.sort()
    println(_MutableList)

}

//[사과, 딸기, 배]
//
//[6, 3, 1]
//[6, 3, 1, 4]
//[6, 3, 8, 1, 4]
//[6, 8, 1, 4]
//[6, 1, 8, 4]
//[1, 4, 6, 8]

 

Set

설명

• 순서가 정렬되지 않고
  중복이 허용되지 않음
  → 인덱스로 위치 지정하여 객체 참조 불가능
  → contains 로 존재하는지 확인하는 식으로만 사용
• Set<T>
  • 생성 시에 넣은 객체를 대체, 추가, 삭제 불가능
  • setOf( … )
• MutableSet<T>
  • 생성 시에 넣은 객체를 대체, 추가, 삭제 가능
  • mutableSetOf( … )
• 추가
  • add( 데이터 )
  • add( 인덱스, 데이터 )
• 삭제
  • remove( 데이터 )
  • removeAt( 인덱스 )

 

코드

fun main() {

    val _Set = mutableSetOf("a","b","c")

    for(item in _Set){
        println(item)
    }

    _Set.add("a")
    println(_Set)
    // 이미 존재하는 a는 추가 불가능

    _Set.add("d")
    println(_Set)
    // 존재하지 않는 d는 추가 가능

    _Set.remove("a")
    println(_Set)

    println(_Set.contains("a"))
    println(_Set.contains("b"))

}

//a
//b
//c
//[a, b, c]
//[a, b, c, d]
//[b, c, d]
//false
//true

 

Map

설명

• 객체를 넣을 때 그 객체를 찾아낼 수 있는 키를 쌍으로 넣어주는 컬렉션
• key(객체를 찾기위한 값)와 value(key와 연결된 객체)는
  내부적으로 MutableMap.MutableEntry에 객체로 담겨있으며
• 이러한 구조 때문에 객체의 위치가 아닌
• 고유한 키를 통해 객체를 참조하는 특징을 가짐
• 같은 키에 다른 객체를 넣으면 개존의 객체가 대체됨
• Map<K, out V>
  • 생성 시에 넣은 객체를 대체, 추가, 삭제 불가능
  • mapOf( … )
• MutableMap<K, V>
  • 생성 시에 넣은 객체를 대체, 추가, 삭제 가능
  • mutableMapOf( … )
  • ‘key’ to ‘value’
• 추가
  • put( 키, 값 )
• 삭제
  • remove( 키 )

 

코드

fun main() {

    val _Map = mutableMapOf(
            "1" to "11",
            "2" to "22",
            "3" to "33"
    )

    for (entry in _Map) {
        println("${entry.key} : ${entry.value}")
    }

    _Map.put("4", "44")
    println(_Map)
    // 추가

    _Map.put("1", "44")
    println(_Map)
    //"1"이라는 키는 이미 존재하기 때문에 추가가 아닌 교체

    _Map.remove("1")
    println(_Map)

    println(_Map["4"])
    // key로 value 가져올 수 있음
    
}

//1 : 11
//2 : 22
//3 : 33
//{1=11, 2=22, 3=33, 4=44}
//{1=44, 2=22, 3=33, 4=44}
//{2=22, 3=33, 4=44}
//44

 

컬렉션 함수

설명

• list, set, map 과 같은 컬렉션 또는 배열에 일반 함수 또는 람다 함수 형태를 사용하여
  for 문 없이 항목을 순회하며 참조하거나 조건을 걸고 구조의 변경까지 가능한 여러 가지 함수 지칭
• forEach
  • 모든 항목을 it 변수를 통해 순서대로 참조
• filter
  • it 에 걸린 조건에 맞는 항목을 컬렉션으로 반환
• map
  • it 에 수식을 적용하여 수식이 적용된 항목을 컬렉션으로 반환
• any / all / none
  • it 에 걸린 조건에 맞는 항목이 ( 하나라도 / 전부 / 아무것도 안 ) 맞는 경우 true 반환
• first / last
  • 일반 - ( 첫 번째 / 마지막 ) 항목
  • 람다 - it 에 걸린 조건에 맞는 항목 중 ( 첫 번째 / 마지막 ) 항목
  • find / findLast 함수로 대체 가능
  • ※ 조건에 맞는 항목이 없는 경우 NoSuchElementExeption 발생
  • firstOrNull / lastOrNull 을 사용하여 방지
• count
  • 일반 - 컬렉션의 모든 항목의 개수 반환
  • 람다 - it 에 걸린 조건에 맞는 항목의 개수 반환
• ☞ 컬렉션 함수를 사용하면 조건문과 반복문을 대체 할 수 있는 장점

---

• associateBy
  • 항목에서 key를 추출하여 map 으로 변환하는 함수
  • it 을 [키로 사용할 속성의 이름] 으로 참조하면 해당 속성을 키로 가지는 map 컬렉션 반환
• groupBy
  • key 가 같은 항목끼리 배열로 묶어 map 으로 만드는 함수
  • 특정한 값을 key로 지정하여 해당 값을 가진 객체끼리 묶은 배열을
    value로 하는 map 컬렉션을 만들어 주는 기능
• partition
  • 항목에 조건을 걸어 true / false 에 따라 두 컬렉션으로 나눠줌
  • 두 컬렉션은 두 객체를 담을 수 있는 pair 라는 클래스 객체로 반환되므로
    두 컬렉션을 first, second로 참조하여 사용 가능
  • Pair 를 직접 받아줄 수 있도록 변수 이름을 (변수1, 변수2) 처럼 2개 선언해주면
    각각의 변수 이름으로 받을 수 있음

---

• flatMap
  • 중괄호 안에서 항목마다 새로운 컬렉션을 생성하면 이를 합쳐서
    하나의 컬렉션으로 반환해줌
• getOrElse
  • 인덱스 위치에 항목이 있으면 해당 항목을 반환하고 아닌 경우
    지정한 기본값을 반환하는 함수
• zip
  • 컬렉션 두 개의 항목을 1:1로 매칭하여 새 컬렉션을 만들어 줌
  • 결과 List 의 항목의 개수는 더 작은 컬렉션를 따름

 

코드

fun main() {

    basic_collection_function()

    println()
    println("====================")
    println()

    associateBy_groupBy_partition()

    println()
    println("====================")
    println()

    flatMap_getOrElse_zip()

}

fun basic_collection_function() {

    val nameList = listOf("박수영", "김지수", "김다현", "신유나", "김지우")

    nameList.forEach { println(it + " ") }

    println()

    println(nameList.filter { it.startsWith("김") })

    println()

    println(nameList.map { "이름 : $it" })

    println()

    println(nameList.any { it == "김지연" })
    println(nameList.all { it.length == 3 })
    println(nameList.none { it.startsWith("이") })

    println()

    println(nameList.first { it.startsWith("김") })
    println(nameList.last { it.startsWith("김") })
    println(nameList.count { it.contains("지") })

}

fun associateBy_groupBy_partition() {

    data class person(val name: String, val birthyear: Int)

    val personlist = listOf(
            person("유나", 1992),
            person("조이", 1996),
            person("츄", 1999),
            person("유나", 2003)
    )

    println(personlist.associateBy { it.birthyear })

    println()

    println(personlist.groupBy { it.name })

    println()

    val (over98, under98) = personlist.partition { it.birthyear > 1998 }
    println(over98)
    println(under98)

}

fun flatMap_getOrElse_zip() {

    val numbers = listOf(-3, 7, 2, -10, 1)

    println(numbers.flatMap { listOf(it * 10, it + 10) })

    println()

    println(numbers.getOrElse(1) { 50 })
    println(numbers.getOrElse(10) { 50 })

    println()

    val names = listOf("A", "B", "C", "D")

    println(names zip numbers)

}