Code__

Immutable Collections : 값을 추가, 삭제, 변경이 불가능 한 콜렉션 
listOf<T>, setOf<T>, mapOf<TKey, TValue> 

// 1. List -> 중복 허용 
val numberList = listOf<Int>(1, 2, 3, 3, 3) 
// 출력 값: [1, 2, 3] 

// 1-1. 원소단위로 출력 
println(numberList[0]) 
println(numberList[1]) 

// 2. Set (집합) 
// 집합의 특징: 중복을 허용하지 않는다, 순서가 없다 
val numberSet = setOf<Int>(4, 5, 6, 6, 6) 
// 출력 값: [4, 5, 6] 

// 2-1. 출력 
// 순서가 없기 때문에 Index가 없다. 
numberSet.forEach { println(it) } 
// 출력 값: 4 5 6 

// 3. Map -> 원소가 쌍을 이루는 Key와 value를 가진다 
// mapOf<Key, Value> 
val numberMap = mapOf<String, Int>("A" to 11, "B" to 22, "C" to 33) 
// 출력 값: {1=A, 2=b, 3=C} 

// 3-1. 출력: Key값을 인덱스로 사용한다. 
println(numberMap["A"]) 
println(numberMap["B"]) 
println(numberMap["C"]) 

Mutable Collection : 추가, 삭제, 변경이 가능한 콜렉션

mutableListOf<T>, mutableSetOf<T>, mutableMapOf<TKey, TValue>

// 1. List
val mNumberList = mutableListOf<Int>(0, 1)

// 1-1. 마지막 Index 뒤에 순서대로 원소를 수가
mNumberList.add(3)
mNumberList.add(4)
println(mNumberList)
// 출력 값: [0, 1, 3, 4]

// 1-2. 위치를 지정하여 원소소를 추가
mNumberList.add(0, 10)
println(mNumberList)
// 출력 값: [10, 0, 1, 3, 4]

// 1-3. 지정한 index에 원소 추가
mNumberList.set(0, 100)
// 출력 값: [100, 0, 1, 3, 4] 해당 위치에 값이 들어가고 기존값 부터 우측 index로 이동된다.

// 1-4. 지정한 index의 원소 제거
mNumberList.removeAt(0)
// 출력 값: [0, 1, 3, 4]

// 2. Set
val mNumberSet = mutableSetOf<Int>(1, 2, 3, 3, 3)

// 2-1. 원소 추가
mNumberSet.add(10)
println(mNumberSet)
// 출력 값: [1, 2, 3, 10]

// 2-2. 원소제거: 제거할 원소의 "값"을 입력한다
mNumberSet.remove(2)
// 출력 값: [1, 3, 10]

// 3. Map
val mNumberMap = mutableMapOf<String, Int>("one" to 1, "two" to 2)

// 3-1. 원소 추가
mNumberMap["three"] = 3
mNumberMap["a"] = 10
mNumberMap.put("kkk", 999)
println(mNumberMap)
// 출력 값: {one=1, two=2, three=3, a=10, kkk=999}

// 3-2. 값 변경
mNumberMap.replace("two", 222)
// 출력 값: {one=1, two=222, three=3, a=10, kkk=999}

// 3-3. key, value의 목록출력
println(mNumberMap.keys)
// 출력 값: [one, two, three, a, kkk]

println(mNumberMap.values)
// 출력 값: [1, 222, 3, 10, 999]

// 3-4. Map의 전체 내용지우기
mNumberMap.clear()

package com.rodunstudio.kotlinbasic.Example 

fun main(args: Array<String>) 
{ 
    // 1. 배열: 같은 Type을 가지는 연속되는 변수의 목록이다. 

    // 2. 배열의 생성 방법 
    // 2-1. Type을 명시하여 생성 (Int Type을 가지는 배열) 
    var group1 = arrayOf<Int>(1, 2, 3, 4, 5) 

    // 2-2. Type을 명시하지 않고 직접 원소를 넣으면 
    // 다양한 Type의 목록을 가지는 배열을 만들 수 있다. 
    var group2 = arrayOf(1, 2, 3.5, "Hello") 

    // 3. Index: 배열 원소의 번호 
    // 3-1. Index를 활용하여 배열의 원소를 가져오기 
    val element1 = group1[0] 
    val element2 = group1[4] 

    // 3-2. Index를 활용하여 배열 원소의 값을 바꾸기 
    group1[0] = 100 
    group1[4] = 222 

    // 4. Type이 지정되어 있는 배열선언 
    val arr = intArrayOf(1, 2, 3) 
    val arr2 = charArrayOf('a', 'b') 
    val arr3 = booleanArrayOf(true, true, false, false, true) 

    // 5. Array를 이용한 배열 선언 (람다식) 
    var Array1 = Array(20, { 0 }) 
    var Array2 = Array(5, { 1; 2; 3; 4 }) 

    var Ary = Array(5, { i -> ( i * i ) } ) 
    for ( emt in Ary ) 
    { 
    	println( emt ) 
    } 
    
    /*결과 
    0 
    1 
    4 
    9 
    16 
    */ 
    // 람다식에 의해서 i의 제곱을 생성하게 된다. 

}