Kotlin in A..Z - Collection

Mutable vs Immutable

Mutable : 내부의 값을 변경할 수 있다.

Immutable : 내부의 값을 변경할 수 없다.

-> mutable로 선언하려면 앞에 mutable을 붙이면 된다. (생략할 시 immutable)

 

fun main() {
    val immutableList = listOf(1, 2, 3)

//    ERROR
//    immutableList.add(1)
//    immutableList.set(0, -1)

    val mutableList = mutableListOf(1, 2, 3)

    mutableList.add(1)
    mutableList[0] = -1

    println("Immutable : $immutableList")
    println("Mutable : $mutableList")
}

Immutable : [1, 2, 3]
Mutable : [-1, 2, 3, 1]

---

Array

fun main() {
    val array1 = arrayOf(0, 1, 2)
    val array2 = Array(3) { i -> i }

    println(array1.contentDeepToString())
    println(array2.contentDeepToString())
}

[0, 1, 2]
[0, 1, 2]

---

List

fun main() {
    val list1 = listOf(0, 1, 2)
    val list2 = List(3) { i -> i }

    println(list1)
    println(list2)
}

[0, 1, 2]
[0, 1, 2]

---

ArrayList

fun main() {
    val arrayList1 = arrayListOf(1, 2, 3)
    val arrayList2 = ArrayList(mutableListOf(1, 2, 3))

    println(arrayList1)
    println(arrayList2)

    // 첫번째 매개변수는 Capacity를 설정하는 것
    // Size와는 다른 개념
    // Capacity는 미리 크기를 할당하는 것이다.
    // add연산을 할 때 오버헤드를 줄이기 위한 방법
    val arrayList = ArrayList<Int>(3)
    println(arrayList)
    println(arrayList.size)

    // mutableList도 ArrayList로 반환한다.
    println(mutableListOf<Int>().javaClass)
}

[1, 2, 3]
[1, 2, 3]
[]
0
class java.util.ArrayList

---

LinkedList

import java.util.*

fun main() {
    val linkedList = LinkedList<Int>(listOf(1, 2, 3))
    println(linkedList)
}

[1, 2, 3]

---

Stack

import java.util.*

fun main() {
    val stack = Stack<Int>()

    stack.addAll(listOf(1, 2, 3))

    while (stack.isNotEmpty()) {
        println(stack.pop())
    }
}

3
2
1

---

Queue

import java.util.*

fun main() {
    val que: Queue<Int> = LinkedList(listOf(1, 2, 3))

    while (que.isNotEmpty()) {
        println(que.poll())
    }
}

1
2
3

---

Deque

fun main() {
    val deque = ArrayDeque(listOf(1, 2, 3, 4))

    while (deque.isNotEmpty()) {
        println(deque.removeFirst())
        println(deque.removeLast())
    }
}

1
4
2
3

---

Map

fun main() {
    /*
    TreeMap : compare로 key : value 확인 -> O(logN)
    HashMap, LinkedHashMap : equals, hashCode로 key : value 확인 O(1)
    HashMap vs LinkedHashMap : HashMap은 입력된 순서를 보장하지 않지만 Linked는 보장한다.
     */
    val map1 = mapOf(Pair("A", 1))
    val map2 = sortedMapOf(Pair("A", 1))
    val map3 = linkedMapOf(Pair("A", 1))
    val map4 = hashMapOf(Pair("A", 1))

    println(map1.javaClass)
    println(map2.javaClass)
    println(map3.javaClass)
    println(map4.javaClass)
}

class java.util.Collections$SingletonMap
class java.util.TreeMap
class java.util.LinkedHashMap
class java.util.HashMap

---

Set

fun main() {
    val set1 = setOf(1, 2, 3)
    val set2 = sortedSetOf(1, 2, 3)
    val set3 = hashSetOf(1, 2, 3)
    val set4 = linkedSetOf(1, 2, 3)

    println(set1.javaClass)
    println(set2.javaClass)
    println(set3.javaClass)
    println(set4.javaClass)
}

class java.util.LinkedHashSet
class java.util.TreeSet
class java.util.HashSet
class java.util.LinkedHashSet

---

Priority Queue

기본은 min heap이다.

Priority Queue를 생성할 때, Comparator를 설정할 수 있다.

-> 람다로 일회성으로 만들 수 있고, Collections.reverseOrder등

fun main() {
    val minHeap = PriorityQueue<Int>()

    minHeap.offer(1)
    minHeap.offer(2)
    minHeap.offer(3)
    minHeap.offer(4)
    minHeap.offer(5)
    while (minHeap.isNotEmpty()) {
        println("minHeap : ${minHeap.poll()}")
    }

    val maxHeap = PriorityQueue<Int> { o1, o2 ->
        o2 - o1
    }

    maxHeap.offer(1)
    maxHeap.offer(2)
    maxHeap.offer(3)
    maxHeap.offer(4)
    maxHeap.offer(5)
    while (maxHeap.isNotEmpty()) {
        println("maxHeap : ${maxHeap.poll()}")
    }

    data class Node(var value: Int) : Comparable<Node> {
        override fun compareTo(other: Node): Int {
            return value - other.value
        }
    }

    val minNodeHeap = PriorityQueue<Node>()
    minNodeHeap.offer(Node(1))
    minNodeHeap.offer(Node(2))
    minNodeHeap.offer(Node(3))
    minNodeHeap.offer(Node(4))
    minNodeHeap.offer(Node(5))
    while (minNodeHeap.isNotEmpty()) {
        println("minNodeHeap : ${minNodeHeap.poll()}")
    }

    val maxNodeHeap = PriorityQueue<Node>(Collections.reverseOrder())
    
    maxNodeHeap.offer(Node(1))
    maxNodeHeap.offer(Node(2))
    maxNodeHeap.offer(Node(3))
    maxNodeHeap.offer(Node(4))
    maxNodeHeap.offer(Node(5))
    while (maxNodeHeap.isNotEmpty()) {
        println("maxNodeHeap : ${maxNodeHeap.poll()}")
    }

    PriorityQueue<Int>()
}

minHeap : 1
minHeap : 2
minHeap : 3
minHeap : 4
minHeap : 5
maxHeap : 5
maxHeap : 4
maxHeap : 3
maxHeap : 2
maxHeap : 1
minNodeHeap : Node(value=1)
minNodeHeap : Node(value=2)
minNodeHeap : Node(value=3)
minNodeHeap : Node(value=4)
minNodeHeap : Node(value=5)
maxNodeHeap : Node(value=5)
maxNodeHeap : Node(value=4)
maxNodeHeap : Node(value=3)
maxNodeHeap : Node(value=2)
maxNodeHeap : Node(value=1)