[TECHIT] 코틀린 8

Array

fun main(){
  
    val array1 = arrayOf(10, 20, 30, 40, 50)
    println("array1 : $array1")
    
    println("array1 : ${array1.contentToString()}")

    val array2  = arrayOf(100, 11.11, "문자열", true)
    println("array2 : ${array2.contentToString()}")

    val array3 = intArrayOf(10, 20, 30, 40, 50)
    val array4 = doubleArrayOf(11.11, 22.22, 33.33, 44.44, 55.55)
    val array5 = arrayOf<String>("문자열1", "문자열2", "문자열3")

    println("array3 : ${array3.contentToString()}")
    println("array4 : ${array4.contentToString()}")
    println("array5 : ${array5.contentToString()}")


    val array6 = Array(5) {
        0
    }
    println("array6 : ${array6.contentToString()}")

 
    val array7 = Array(5){
        it
    }
    println("array7 : ${array7.contentToString()}")

    
    val array8 = Array(10){
        (it + 1) * 3
    }
    println("array8 : ${array8.contentToString()}")

    println("-----------------------------------------")

    for(item in array1){
        println("item : $item")
    }

    println("-----------------------------------------")
    // 다 차원 배열 만들기
    val array9 = arrayOf(
        arrayOf(10, 20, 30),
        arrayOf(40, 50, 60),
        arrayOf(70, 80, 90)
    )
    println("array9 : $array9")
    println("array9 : ${array9.contentToString()}")
    println("array9 : ${array9.contentDeepToString()}")

    for(item in array9){
        for(item2 in item){
            println("item2 : $item2")
        }
    }

    println("-------------------------------------------")
  다.
    println("array1 0 : ${array1[0]}")
    println("array1 1 : ${array1[1]}")
 
    // [ ] 연산자를 사용하는 것과 동일하다.
    println("array1.get(0) : ${array1.get(0)}")
    println("array1.get(1) : ${array1.get(1)}")

    println("----------------------------------------------------")

    // 새로운 값을 저장한다.
    println("array1 : ${array1.contentToString()}")

    array1[0] = 100
    println("array1 : ${array1.contentToString()}")

    array1.set(1, 200)
    println("array1 : ${array1.contentToString()}")

    println("---------------------------------------------------")

    // 배열이 관리하는 값의 개수
    println("array1 size : ${array1.size}")

    println("---------------------------------------------------")

    // 배열에 요소 추가
    // 새로운 배열이 생성된다.
    println("array1 : ${array1.contentToString()}")

    val array10 = array1.plus(60)
    println("array1 : ${array1.contentToString()}")
    println("array10 : ${array10.contentToString()}")

    println("---------------------------------------------------")

    val array11 = array1.sliceArray(1..3)
    println("array1 : ${array11.contentToString()}")

    println("-----------------------------------------------------")
    // 배열이 제공하는 다양한 메서드들
    println("첫 번째 값 : ${array1.first()}")
    println("마지막 값 : ${array1.last()}")
    println("30의 위치 : ${array1.indexOf(30)}")
    println("평균 : ${array1.average()}")
    println("합 : ${array1.sum()}")
    println("개수 : ${array1.count()}")
    println("개수 : ${array1.size}")
    println("30을 포함하는 가 : ${array1.contains(30)}")
    println("1000을 포함하는 가 : ${array1.contains(1000)}")
    println("30을 포함하는가 : ${30 in array1}")
    println("1000을 포함하는 가 : ${1000 in array1}")
    println("최대 : ${array1.max()}")
    println("최소 : ${array1.min()}")

    println("-----------------------------------------------------")
    // 정렬
    // 값이 정렬된 새로운 배열을 생성한다.
    val array12 = arrayOf(5, 1, 3, 7, 10, 8)
    // 오름 차순 정렬
    val array13 = array12.sortedArray()
    // 내림 차순 정렬
    val array14 = array12.sortedArrayDescending()

    println("array12 : ${array12.contentToString()}")
    println("array13 : ${array13.contentToString()}")
    println("array14 : ${array14.contentToString()}")
}

람다식을 통한 배열을 생성할 수 있다. 람다식 코드를 수행하여 제일 마지막에 작성되어 있는 값을 배열의 요소로 담아준다. 특정 식을 통해 계산된 결과나 패턴을 가지는 배열을 만들 때 사용한다. 배열 요소에 접근하기 위해서는 get 메서드를 통해서 가져오거나 [ ]연산자를 사용한다. [ ] 연산자는 get 메서드를 호출해서 값을 가져온다.

String

fun main(){
    val str1 = "안녕하세요"
    println("str1 : $str1")

    // 원하는 번째의 글자를 가져올 수 있다.
    println("str1[0] : ${str1[0]}")
    println("str1[1] : ${str1[1]}")

    // 원하는 번째의 글자를 다른 글자로 변경한다.
    // 문자열은 글자를 바꾸는 것이 불가능하다.
    // str1[0] = "A"

    println("----------------------------------------")

    // 원하는 부분의 글자들을 추출하여 새로운 문자열로 받아온다.
    // 두 번째 글자 ~ 네 번째 글자
    val str2 = str1.substring(1..3)
    println("str2 : $str2")

    println("----------------------------------------")

    // 문자열 비교
    val str3 = "Hello World"
    val str4 = "hello world"
    val str5 = "Hello World"

    // 코틀린에서 == 를 가지고 비교를 하면 문자열 값 자체를 비교하는 작업을 수행한다.
    if(str3 == str4){
        println("str3과 str4는 같습니다")
    }
    
    if(str3 == str5){
        println("str3과 str5는 같습니다")
    }

    
    println(str3.compareTo(str4))
    println(str3.compareTo(str5))

    // 두 번째 매개 변수에 true를 넣어주면
    // 모두 소문자로 변환한 다음 코드값을 빼는 작업을 수행한다
    // 대소문자를 구분하고 같은가를 확인한다.
    println(str3.compareTo(str4, true))

    // 대소문자를 무시하고 같은지를 비교한다.
    if(str3.equals(str4, true)){
        println("대소문자 무시하고 같습니다")
    }

    println("------------------------------------------------------")

    // 구분자를 기준으로 문자열을 나눈다.
    val str6 = "ab cd ef gh"
    // 띄어쓰를 기준으로 나눈다.
    val r6 = str6.split(" ")
    println("r6 : $r6")

    for(temp6 in r6){
        println(temp6)
    }

    println("-----------------------------------------")
    // 문자열 병합
    val str7 = "abc"
    // 두 문자열을 합친 새로운 문자열을 만들어준다.
    val str8 = str7 + "def"
    // 문자열이 아닌 값을 새로운 문자열로 만든다음
    // 두 문자열을 합친 새로운 문자열을 만들어준다.
    val str9 = str8 + 10
    println("str7 : $str7")
    println("str8 : $str8")
    println("str9 : $str9")

    // String은 문자열 합치는 작업을 수행할 때 마다 새로운 문자열 객체가
    // 계속 생성된다(String은 관리하는 문자열 수정이 불가능하기 때문에...)
    // 이럴 때는 StringBuffer를 사용한다.
    val buffer1 = StringBuffer()
    buffer1.append("abc")
    buffer1.append(100)
    buffer1.append(11.11)
    println("buffer1 : $buffer1")
}

compareTo : 같으면 0, 다르면 0이 아닌 값이 나온다.compareTo 는 문자열을 구성하는 각 글자의 코드 값을 합산한 결과를 뺀 값을 전달한다. 두 번째 매개 변수에 true를 넣어주면 모두 소문자로 변환한 다음 코드값을 빼는 작업을 수행한다. 대소문자를 구분하고 같은가를 확인한다.

List

fun main(){

    // 리스트 생성
    // 불변형 리스트
    // 리스트 생성 이후 값의 추가, 수정, 삽입, 삭제가 불가능하다.
    val list1 = listOf(10, 20, 30, 40, 50)
    println("list1 : $list1")

    val list2 = listOf("문자열1", "문자열2", "문자열3")
    println("list2 : $list2")

    val list3 = listOf(100, 11.11, "문자열", true)
    println("list3 : $list3")

    // 수정 가능한 리스트
    // ArrayList로 생성된다.
    val list4 = mutableListOf<Int>()
    val list5 = mutableListOf("문자열1", "문자열2", "문자열3")
    println("list4 : $list4")
    println("list5 : $list5")

    // 비어있는 수정 불가능한 리스트
    val list6 = emptyList<Int>()
    println("list6 : $list6")

    // null값을 제외하고 생성한다.
    val list7 = listOf(10, 20, null, 40, null, 60, 70)
    val list8 = listOfNotNull(10, 20, null, 40, null, 60, 70)

    println("list7 : $list7")
    println("list8 : $list8")

    println("---------------------------------------------")

    // for 문 사용
    for(item in list1){
        println("item : $item")
    }

    // 개수
    println("list1 size : ${list1.size}")

    println("-------------------------------------------------------")
    // 관리하는 객체(값)에 접근
    // [ ] 연산자를 통해 순서값(0부터 1씩 증가)를 지정하여 접근한다.
    println("list1 0 : ${list1[0]}")
    println("list1 1 : ${list1[1]}")

    println("---------------------------------------------------------")
    // 일부를 발췌하여 새로운 리스트로 생성한다.
    val list9 = listOf(10, 20, 30, 10, 20, 30)

    // 지정된 값이 앞에서 부터 몇 번째에 있는가
    val index1 = list9.indexOf(20)
    println("index1 : $index1")

    // 지정된 값이 뒤에서 부터 찾아서 앞에서 부터 몇 번째에 있는가
    val index2 = list9.lastIndexOf(20)
    println("index2 : $index2")

    // 일부를 발췌해 새로운 리스트로 만들어준다.
    // 순서 값 1 ~ 3 - 1 까지
    val list10 = list9.subList(1, 3)
    println("list10 : $list10")

    println("------------------------------------------------------")

    val list20 = listOf(10, 20, 30)
    val list21 = mutableListOf(10, 20, 30)

    // 수정 불가능한 리스트에 값 추가
    // 수정 불가능한 리스트에는 추가, 삭제, 수정, 삽입 등의 메서드가 없다.
    // list20.add(100)
    // list20[1] = 200

    // 수정이 가능한 리스트에 대한 추가, 수정, 삭제, 삽입
    // 추가
    list21.add(40)
    list21.add(50)
    list21.addAll(listOf(60, 70, 80, 90, 100))
    println("list21 : $list21")

    // 삽입
    // 순서값 1(두 번째)에 1000을 삽입하고 그 이후의 값들을 뒤로 밀린다.
    list21.add(1, 1000)
    println("list21 : $list21")

    // 순서값 3(네 번째)에 지정된 요소가 관리하는 값들을 모두 추가하고 그 이후의 값들은 뒤로 밀린다.
    list21.addAll(3, listOf(2000, 3000, 4000, 5000))
    println("list21 : $list21")

    // 제거
    // 지정된 값을 제거한다.
    list21.remove(1000)
    println("list21 : $list21")

    // 제거 하고자 하는 값이 같은 것이 여러개가 있다면 제일 앞쪽에는 값 하나만 제거한다.
    list21.add(1000)
    list21.add(1000)
    list21.add(1000)
    println("list21 : $list21")
    list21.remove(1000)
    println("list21 : $list21")

    // 없는 값을 제거
    // 아무 작업도 하지 않는다.
    list21.remove(10000)
    println("list21 : $list21")

    // 제거 하기 위해 지정한 것들을 모두 제거한다.
    list21.removeAll(listOf(2000, 3000, 4000, 5000))
    println("list21 : $list21")

    // removeAll을 통해 같은 값이 다수 저장되어 있는 것을 제거
    list21.removeAll(listOf(1000))
    println("list21 : $list21")

    // 위치를 지정하여 제거한다.
    // 두 번째 값을 제거한다.
    list21.removeAt(1)
    println("list21 : $list21")


    // 값을 수정한다.
    // 두 번째 값을 200으로 덮어 씌운다.
    list21.set(1, 200)
    println("list21 : $list21")

    list21[2] = 300
    println("list21 : $list21")

    println("--------------------------------------------")
    val list100 = listOf(10, 20, 30, 40, 50)

    // list 안에 저장되어 있는 객체(값)을 추출하여 mutableList로 생성하여 반환한다.
    val list200 = list100.toMutableList()
    list200.add(60)

    println("list100 : $list100")
    println("list200 : $list200")

    // mutableList 안에 저장되어 있는 객체(값)을 추출하여 list로 생성하여 반환한다.
    val list300 = list200.toList()
    // list300.add(70)

}

관리할 객체들(값들)이 있고 나중에 추가, 삭제 등을 하지 않을 경우 : arrayOf
관리할 객체들(값들)이 없으며 나중에 추가, 삭제 등을 하는 경우 : ArrayList, mutableListOf
관리할 객체들(값들)이 있고 나중에 추가, 삭제 등을 하는 경우 : mutableListOf
관리할 객체들(값들)이 있고 나중에 추가, 삭제 등을 하지 않고 관리하는 값을 변경하지 못하게 강제하고자 할 때 : listOf

Map

fun main(){

    // 수정 불가능한 map
    // 이름 to 값(객체)
    // 이름은 꼭 문자열이 아니어도 된다
    val map1 = mapOf("key1" to 10, "key2" to 20, "key3" to 30)
    println("map1 : $map1")

    val map2 = mapOf(10 to "str1", 20 to "str2", 30 to "str3")
    println("map2 : $map2")

    // 수정 가능한 map
    val map3 = mutableMapOf("key1" to 10, "key2" to 20, "key3" to 30)
    println("map3 : $map3")

    // mapOf 혹은 mutableMapOf를 사용할 때 제네릭을 설정하는 것을 권장하고 있다.
    // 이름과 값의 타입이 모두 같을 경우
    val map4 = mapOf<String, Int>("key1" to 10, "key2" to 20, "key3" to 30)
    println("map4 : $map4")

    // 만약 이름이나 값의 타입이 다양하게 저장되다면 Any로 설정해준다.
    val map5 = mapOf<String, Any>("key1" to 10, "key2" to 11.11)
    println("map5 : $map5")

    // 제네릭은 어떠한 경우라도 생략이 가능하기 때문에 그냥 생략하고 쓰세요...
    val map6 = mapOf("key1" to 10, "key2" to 20, "key3" to 30)
    val map7 = mapOf("key1" to 10, "key2" to 11.11)
    println("map6 : $map6")
    println("map7 : $map7")

    // 비어있는 map
    // 비어있는 map을 만들 때는 값이 없기 때문에 제네릭을 자동으로 설정할 수 없다.
    // 따라서 제네릭을 무조건 작성해 줘야 한다.
    val map8 = mapOf<String, Int>()
    val map9 = mutableMapOf<String, Int>()

    println("---------------------------------------")
    // 관리하는 객체(값)을 가지고 온다.
    val map10 = mapOf("key1" to 10, "key2" to 20, "key3" to 30)
    val map11 = mutableMapOf("key1" to 10, "key2" to 20, "key3" to 30)

    println("map10 key1 : ${map10.get("key1")}")
    println("map11 key1 : ${map11.get("key1")}")

    println("map10 key2 : ${map10["key2"]}")
    println("map11 key2 : ${map11["key2"]}")

    println("----------------------------------------")

    // 관리하는 값(객체)의 개수
    println("map1 size : ${map1.size}")
    // 이름들을 가져온다.
    println("map1 keys : ${map1.keys}")
    // 값들을 가져온다.
    println("map1 values : ${map1.values}")

    // 이 이름의 값이 있는지...
    println("map1 contains key - key1 : ${map1.containsKey("key1")}")
    println("map1 contains key - key100 : ${map1.containsKey("key100")}")

    // 이 값이 저장되어 있는지...
    println("map1 contains value - 10 : ${map1.containsValue(10)}")
    println("map1 contains value - 100 : ${map1.containsValue(100)}")

    println("-------------------------------------")

    val map12 = mutableMapOf("a1" to 10, "a2" to 20)
    println("map12 : $map12")

    // 추가
    map12.put("a3", 30)
    println("map12 : $map12")

    map12["a4"] = 40
    println("map12 : $map12")

    // 수정 : 없는 이름으로 값을 넣어주면 추가가 되고 있는 이름으로 값을 넣어주면
    // 수정된다.
    map12["a1"] = 100
    println("map12 : $map12")

    // 삭제
    map12.remove("a1")
    println("map12 : $map12")

    println("--------------------------------------------")

    // mapOf -> mutableMapOf
    val map13 = mapOf("a1"  to 10, "a2" to 20, "a3" to 30)

    val map14 = map13.toMutableMap()
    map14["a4"] = 40
    println("map14 : $map14")

    // mutableMapOf -> mapOf
    val map15 = map14.toMap()
    // map15["a5"] = 50
}

Set

fun main(){

    // 수정 불가능한 set
    val set1 = setOf(10, 20, 30, 10, 20, 30)
    // 수정 가능한 set
    val set2 = mutableSetOf(10, 20, 30, 10, 20, 30)
    println("set1 : $set1")
    println("set2 : $set2")

    // 추가
    set2.add(40)
    println("set2 : $set2")

    set2.add(10)
    println("set2 : $set2")

    // set -> list
    val list1 = set2.toList()
    val list2 = set2.toMutableList()

    println("list1 : $list1")
    println("list2 : $list2")

    // list -> set
    val list3 = listOf(10, 20, 30, 10, 20, 30)

    val set3 = list3.toSet()
    val set4 = list3.toMutableSet()
    println("set3 : $set3")
    println("set4 : $set4")

}