[Kotlin] 컬렉션

💡배열, List, Map, Set💡

 

---

▪️배열

· 0부터 시작되는 인덱스 번호로 관리한다.

· 다양한 타입의 값을 배열에 담을 수 있으며 한 가지 타입으로 제한하여 값을 담을 수도 있다.

fun main() {
    // 내용을 출력하려면 contentToString()
    val arr1 = arrayOf(10, 20, 30, 40, 50)
    println("arr1 : $arr1")
    println("arr1 : ${arr1.contentToString()}")

    // 다양한 타입을 넣기
    val arr2 = arrayOf(10, 20.0, "가나다", true)
    println("arr2 : ${arr2.contentToString()}")

    // 한 가지 타입만 넣기
    // 맨 앞에 타입+ArrayOf를 붙이거나 제네릭 사용
    val arr3 = intArrayOf(10, 20, 30, 40, 50)
    val arr4 = arrayOf<Double>(1.0, 2.0, 3.0, 4.0, 5.0)
    println("arr3 : ${arr3.contentToString()}")
    println("arr4 : ${arr4.contentToString()}")
}

 

배열 생성

· arrayOf 함수가 아닌 Array 클래스를 통해 직접 객체를 생성할 수 있다.

fun main() {
    // 크키는 5, 값들은 0으로 만들기
    val arr1 = Array(5, {0})
    println("arr1 : ${arr1.contentToString()}")

    // 람다를 이용
    // it에는 0부터 1씩 증가하는 값이 들어감
    val arr2 = Array(5) {it * 2}
    println("arr2 : ${arr2.contentToString()}")
}

 

for문 사용

· 배열이 가지고 있는 값의 크기만큼 반복하여 사용할 수 있다.

fun main() {
    val arr1 = arrayOf(10, 20, 30, 40, 50)
    for(item in arr1) {
        print("$item, ")
    }
}

 

다 차원 배열

· 배열 안에 배열이 있는 것을 의미한다.

fun main() {
    val arr1 = arrayOf(arrayOf(10, 20, 30), arrayOf(40, 50, 60), arrayOf(70, 80, 90))
    // 주소값만 나옴
    println("arr1 : $arr1")
    println("arr1 : ${arr1.contentToString()}")
    // 값들을 나오게 하려면 contentDeepToString()
    println("arr1 : ${arr1.contentDeepToString()}")

    // 다 차원 배열을 for문에 사용
    for(item1 in arr1) {
        for(item2 in item1) {
            print("$item2, ")
        }
    }
}

 

배열 요소 접근

fun main() {
    // 특정 값 가져오기
    val arr1 = arrayOf(10, 20, 30, 40, 50)
    println("arr1 0 : ${arr1[0]}")
    println("arr1 1 : ${arr1[1]}")
    println("arr1 2 : ${arr1[2]}")
    println("arr1 3 : ${arr1[3]}")
    println("arr1 4 : ${arr1[4]}")

    // 값 수정하기
    arr1[0] = 100
    arr1.set(1, 200)
    println("arr1 : ${arr1.contentToString()}")

    // 배열의 크기
    println("arr1 size : ${arr1.size}")
}

 

배열의 다양한 메서드들

· Kotlin에서는 Java보다 더 다양한 메서드들을 제공한다.

· 이 밖에도 더 많은 메서드가 존재한다.

fun main() {
    val arr1 = arrayOf(10, 20, 30, 40, 50)

    // 배열 추가하기
    val arr2 = arr1.plus(60)
    println("arr2 : ${arr2.contentToString()}")

    // 특정 부분 가져오기 (1 ~ 3)
    val arr3 = arr1.sliceArray(1..3)
    println("arr3 : ${arr3.contentToString()}")

    println("첫 번째 값 : ${arr1.first()}")
    println("마지막 값 : ${arr1.last()}")
    println("30의 위치 : ${arr1.indexOf(30)}")
    println("평균 값 : ${arr1.average()}")
    println("합친 값 : ${arr1.sum()}")
    println("개수 : ${arr1.count()}")
    println("개수 : ${arr1.size}")
    println("30을 포함하는지 : ${arr1.contains(30)}")
    println("1000을 포함하는지 : ${arr1.contains(1000)}")
    println("30을 포함하는지 : ${30 in arr1}")
    println("1000을 포함하는지 : ${1000 in arr1}")
    
    val arr4 = arrayOf(5, 1, 3, 4, 2)
    // 오름차순
    val arr5 = arr4.sortedArray()
    println("arr5 : ${arr5.contentToString()}")
    // 내림차순
    val arr6 = arr4.sortedArrayDescending()
    println("arr6 : ${arr6.contentToString()}")
}

 

 

▪️List

· 배열과 동일하게 인덱스 번호를 통해 객체를 관리한다.

· 배열은 크기가 정해지면 변경할 수 없지만 List는 추가, 삭제 등이 가능하다.

fun main() {
    // 불변형 리스트
    val list1 = listOf(10, 20, 30, 40, 50)
    println("list1 : $list1")

    // 가변형 리스트
    // 값이 없다면 제네릭으로 타입을 정해줘야 함
    val list2 = mutableListOf<Int>()
    // String 타입의 값이 들어있기 때문에 타입 추론 가능
    val list3 = mutableListOf("가", "나", "다")
    println("list2 : $list2")
    println("list3 : $list3")

    // 비어져있는 불변형리스트
    val list4 = emptyList<Int>()
    println("list4 : $list4")
    
    // null을 제외한 값들을 사용
    val list5 = listOfNotNull(10, 20, null, 30, null, 40, 50)
    println("list5 : $list5")
}

 

for문 사용

fun main() {
    val list1 = listOf(10, 20, 30, 40, 50)

    for(item in list1) {
        print("$item, ")
    }
}

 

List 요소 접근

fun main() {
    val list1 = listOf(10, 20, 30, 40, 50)

    // 특정 값 가져오기
    println("list1 0 : ${list1.get(0)}" )
    println("list1 1 : ${list1[1]}" )

    val list2 = listOf(10, 20, 30, 40, 50, 10)

    // 특정 요소 찾기
    val index1 = list2.indexOf(10)
    println("10 index : $index1")

    // indexOf : 앞에서부터 찾음
    // lastIndexOf : 뒤에서부터 찾음
    val index2 = list2.lastIndexOf(10)
    println("10 index : $index2")

    // 특정 값을 추출해 새로운 리스트를 생성
    val list3 = list1.subList(1, 3)
    println("list3 : $list3")
}

 

가변형 리스트의 메서드

fun main() {
    val list1 = mutableListOf<Int>()

    // 추가하기
    list1.add(10)
    list1.add(20)
    list1.add(30)
    println("list1 : $list1")

    // 배열이나 리스트 추가
    list1.addAll(listOf(40, 50, 60))
    println("list1 : $list1")

    // 특정 요소 삽입 (index 1을 100으로 변경)
    list1.add(1, 100)
    println("list1 : $list1")

    // 전체 삽입
    list1.addAll(2, listOf(400, 500, 600))
    println("list1 : $list1")

    // 특정 요소 삭제
    list1.remove(100)
    println("list1 : $list1")

    // 특정 요소들 삭제
    list1.removeAll(listOf(400, 500))
    println("list1 : $list1")

    // 해당 인덱스 삭제
    list1.removeAt(1)
    println("list1 : $list1")

    // 값 변경
    list1.set(0, 100)
    list1[1] = 200
    println("list1 : $list1")

    val list2 = listOf<Int>()

    // 불변형 -> 가변형
    // 값들을 그대로 가져와 가변형으로 바꾼다
    val list3 = list2.toMutableList()
    list3.add(100)
    println("list3 : $list3")

    // 가변형 -> 불변형
    val list4 = list3.toList()
    // 가변형이므로 오류가 뜸
    //list4.add(200)
}

 

 

▪️Map

· List는 index 번호를 가지고 관리를 했다면 Map은 이름을 통해 관리한다.

fun main() {
    // 이름으로 사용 할 타입, 객체의 타입을 작성해줘야 함
    // 추론이 가능하다면 생략 가능
    // 불변형
    val map1 = mapOf("key1" to 10, "key2" to 20, "key3" to 30)
    println("map1 : $map1")

    // 가변형
    val map2 = mutableMapOf<String, Int>()
    println("map2 : $map2")

    // 타입을 다양하게 쓴다면 Any를 쓰면 됨
    val map3 = mutableMapOf<String, Any>("key1" to 10, "key2" to "가", "key3" to false)
    println("map3 : $map3")

    // 객체 가져오기
    println("map1 key1 : ${map1.get("key1")}")
    println("map1 key2 : ${map1["key2"]}")

    // 메서드
    println("map1 size : ${map1.size}")
    println("map1 keys : ${map1.keys}")
    println("map1 values : ${map1.values}")

    // key로 유무 확인
    println("map1 containts key1 : ${map1.containsKey("key1")}")
    println("map1 containts key100 : ${map1.containsKey("key100")}")

    // value로 유무 확인
    println("map1 containts value 10 : ${map1.containsValue(10)}")
    println("map1 containts value 100 : ${map1.containsValue(100)}")

    // 가변형 Map의 메서드
    println("map2 : $map2")

    // 추가하기
    map2.put("key1", 100)
    println("map2 : $map2")

    // 없는 이름으로 추가하면 자동으로 추가가 됨
    map2["key2"] = 200
    println("map2 : $map2")

    // 같은 이름이 존재한다면 value 변경
    map2.put("key1", 1000)
    map2["key2"] = 2000
    println("map2 : $map2")

    // 삭제
    map2.remove("key1")
    println("map2 : $map2")

    // 불변형 -> 가변형
    val map100 = map1.toMutableMap()
    map100["key100"] = 1000
    println("map100 : $map100")

    // 가변형 -> 불변형
    val map200 = map100.toMap()
    // 불변형이므로 오류
    //map200["key100"] = 1000
}

 

 

▪️Set

· 객체의 이름이나 순서 등으로 관리하는 주체가 없는 컬렉션이다.

· 중복된 객체를 담을 수 없다.

fun main() {
    val set1 = setOf(1, 5, 10, 1, 5, 10)
    println("set1 : $set1")

    val set2 = mutableSetOf<Int>()
    println("set2 : $set2")

    // for문을 통해 객체를 순회해야 함
    for(item in set1) {
        println("$item")
    }

    // 크기
    println("set1 : ${set1.size}")

    // 추가를 할 수 있지만 같은 객체일 경우 추가되지 않음
    set2.add(10)
    set2.add(20)
    set2.addAll(listOf(30, 40, 50, 1, 5, 10))
    println("set2 : $set2")

    // 값에 해당하는 것만 삭제
    set2.remove(5)
    println("set2 : $set2")
    
    // 불변형 -> 가변형, 가변형 -> 불변형 변경은 List와 Map이랑 똑같음
    // Set은 List로, List는 Set으로 서로 변경 가능
}

 

---