Collections

Collection Interface

public interface Collection<out E> : Iterable<E> {
    public val size: Int
    public fun isEmpty(): Boolean
    public operator fun contains(element: @UnsafeVariance E): Boolean
    override fun iterator(): Iterator<E>
    public fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
}

• Iterable 에서 확장
• 불변형이므로 Collection 으로부터 확장된 Set, List는 읽기 전용
• Collection Interface Member
  • size
  • isEmpty()
  • contains(element:E)
  • containsAll(element: Collection)

MutableCollection Interface

  public interface MutableCollection<E> : Collection<E>, MutableIterable<E> {

    override fun iterator(): MutableIterator<E>
	
  	// 인자로 전달받은 요소를 추가하고 true를 반환 이미 요소가 있거나 중복이 허용되지 않는 경우 false를 반환한다
    public fun add(element: E): Boolean
	
  	// 인자로 전달받은 요소를 삭제하고 성공시 true, 실패시 false 반환
    public fun remove(element: E): Boolean

  	// 컬렉션을 인자로 전달받아 모든 요소를 추가
    public fun addAll(elements: Collection<E>): Boolean
	
  	// 컬렉션 인자로 전달받은 요소를 삭제하고 성공시 true, 실패시 false 반환
    public fun removeAll(elements: Collection<E>): Boolean

  	// 인자로 전달받은 요소만 보유하도록 한다. 성공시 true, 실패시 false를 반환한다
    public fun retainAll(elements: Collection<E>): Boolean
	
  	// 컬렉션의 모든 요소 삭제
    public fun clear(): Unit
}

• 가변형 컬렉션을 지원
  • 요소 추가/ 제거 기능

Interface

• List
  • 불변형 : listOf
  • 가변형 : mutableListOf, arrayListOf
• Set
  • 불변형 : setOf
  • 가변형 : mutableSetOf, hashSetOf, linkedSetOf, sortedSetOf
• Map
  • 불변형 : mapOf
  • 가변형 : mutableMapOf, hashMapOf, linkedMap, sortedMapOf

List

• 순서에 따라 정렬된 요소를 가지는 컬렉션
• 불변형으로 헬퍼 함수인 ListOf()를 사용
  • 헬퍼 함수 : 직접 요소를 선언하기 보다 특정 함수의 도움을 통해 생성
• 가변형으로 mutableListOf() 사용
• 원하는 만큼의 가변 인자를 가질 수 있음 vararg 선언가능

헬퍼 함수 listOf() 원형

public fun <T> listOf(varage elements:T): List<T>

• vararg 는 가변 인자를 받을 수 있기 때문에 원하는 만큼 요소를 지정
• 값을 반환 시 List<T> 사용
• 형식 매개변수 <T> 는 필요에 따라 원하는 자료형을 지정해 선언
  • 사용하지 않으면 <Any> 가 기본값으로 어떤 자료형이든 혼합 사용 가능

사용 예시

사용법

fun main() {
    var numbers: List<Int> = listOf(1,2,3,4,5)
    var names: List<String> = listOf("one", "two", "three")
    var mixed = listOf(1,2,"3","4")

    for (name in names) {
        println(name)
    }

    for (num in numbers) print(num)
    println()
	
  	// 가변형으로 변경
    val mutableNames = names.toMutableList()
    mutableNames.add("four")
    println(mutableNames)
}

for와 indices 멤버로 접근

fun main{
	val fruits = listOf("banana", "kiwi", "strawberry")
  	for (item in fruits) {
  		println(item)
  	}
  
  	for (index in fruits.indices) {
  		println(fruits[index]);
  	}
}

기타 List 함수

emptyList()

val emptyList: List<String> = emptyList<String>();

listOfNotNull()

• null 을 제외한 요소만 반환

	val emptyList2: List<Int> = listOfNotNull(2, 45, null, 33, 1)
    println(emptyList2)

추가 멤버 메서드

• get(index: Int) : 특정 인덱스를 인자로 받아 해당 요소를 반환한다
• indexOf(element :E) : 인자로 받은 요소가 첫번째로 나타는 인덱스를 반환, 없으면 -1
• lastIndexOf(element:E) : 인자로 받은 요소가 마지막으로 나타나는 인덱스 반환, 없으면 -1
• listIterator() : 목록에 있는 iterator 반환
• subList(fromIndex:Int, toIndex:Int) : from-to범위의 요소 목록 반환

Set

• 정해진 순서가 없는 요소의 집합
• 요소가 중복 될 수 없음

생성 함수

• 불변형 : setOf()

val mixedSet = setOf("Hello", 3, "world",4) // Hello, 3, world, 4
val intSet: Set<Int> = setOf<Int>(1,4,4) // 1,4

• 가변형 : mutableSetOf()

val animal = mutable("test","this","example") // test, this, example
animal.add("test") // test, this, example
animal.remove("test") // this, example

hashSetOf()

• 불변성 선언이 없기 때문에 해시 테이블에 요소를 저장할 수 있는 자바의 HashSet컬렉션을 만든다.
• 결과와 같이 입력 순서와 중복된 요소는 무시된다
• 정렬 기능은 없지만 해시값을 통해 찾아냄으로 검색속도는 O(1)상수시간

val intsHashSet:HashSet<Int> = hashSetOf(6, 3, 4, 7) // 불변성 기능이 없음
intsHashSet.add(5) // 추가
intsHashSet.remove(6) // 삭제
println(intsHashSet) // [3,4,5,7]

hashTable

• 키와 인덱스를 활용한 검색과 변경이 빠른 쿼리 구조

TreeSet

sortedSetOf()

• 자바의 treeSet 컬렉션을 정렬된 상태로 반환
• java.util.* 패키지를 임포트 해야한다
• TreeSet 은 저장된 데이터의 값에 따라 정렬
  • 이진 탐색 트리 인 RB(red-black) 트리 알고리즘을 사용
• HashSet보다 추가, 삭제 시 시간이 걸리지만 검색과 정렬이 뛰어나다

RB 트리

• 이진 탐색 트리가 한쪽으로 치우친 트리 구조를 가지게 되는 경우 트리 높이 만큼 걸리게 되는 최악의 경우 시간이 만들어 질 수 있다
• RB 트리는 이 단점을 RED와 black 의 색상으로 치우친 결과 값이 구분 되도록 해 최악의 경우에도 검색 등의 처리에서 일정 시간을 보장한 자료구조

LinkedHashSet

linkedSetOf()

• 자바의 LinkedHashSet 자료형을 반환하는 헬퍼 함수
• 링크드 리스트를 사용해 구현된 해시 테이블에 요소를 저장
• 메모리 공간 효율성이 좋다
• hashset, treeset 보다 느리지만 데이터 구조상 다음 데이터를 가리키는 포인터 연결을 통해 메모리 저장 공간을 좀 더 효율적으로 사용
  

Map

• 키와 값으로 구성된 요소를 저장
  • 키와 값은 모두 객체이다
• 키는 중복될 수 없지만 값은 중복 가능
  • 만약 기존에 저장된 키와 동일하면 기존의 값은 없어지고 새로운 값으로 대체됨
• Map에서도 자바의 HashMap, SortedMap, LinkedHashMap 사용
  • sortedMap(), sortedMapOf(), linkedMapOf() 초기화
  • sorted 의 경우 오름차순 형태로 사용한다
  • 내부 구조는 Set과 비슷하게 해시, 트리, 링크드 리스트의 자료구조로 구현
• 멤버 함수
  • size : 맵 컬렉션의 크기를 반환
  • keys : 모든 키를 반환한다
  • values : 모든 값을 반환한다
  • isEmpty() : 맵이 비어있는지 확인하고 비어있으면 true, 비어있지 않으면 false를 반환한다
  • containsKey(Key: K) : 인자에 해당하는 키가 있으면 true, 없으면 false를 반환
  • containsValue(Value: V) : 인자에 해당하는 값이 있으면 true, 없으면 false 반환
  • get(key :K) : 키에 해당하는 값을 반환 값이 없으면 null 반환

MapOf()

• 불변형
• 사용 예시

//val map: Map<키 자료형 : 값 자료형 > = mapOf(키 to 값[,...])  
val langMap: Map<Int, String> = map(11 to "Java", 22 to "Kotlin", 33 to "C++")
for ((key, value) in langMap) {
	println("key=$key, value=$value")
}

mutableMapOf()

• 가변형
• 멤버 변수
• 추가 멤버 함수
  • put(key: K, value:V) : 키와 값의 쌍을 맵에 추가한다.
  • remove(key: K) : 키에 해당하는 요소를 맵에서 제거한다
  • putAll(from: Map<out, K, V>) : 인자로 주어진 Map 데이터를 갱신하거나 추가한다.
  • clear() : 모든 요소를 지운다
• 사용 예시

val cityMap: MutableMap<String,String> = 
  	mutableMapOf("korea" to "seoul", "china" to beijing", "japan" to "tokyo")
val addData = mutableMapOf("USA" to "washington")
cityMap.putAll(addData)

Reference

• 코틀린 프로그래밍 기본 2