Kotlin에서의 배열(array)과 List & Java와 차이점

: ) YOUNG·2022년 5월 3일
2

Kotlin

목록 보기
1/7
post-thumbnail

Kotlin Java의 배열 생성 차이점



보통 자바에서 배열을 생성할 때는 아래와 같은 방법을 사용한다.
		int array[] = new int[4]; // 크기만 할당해서 초기화
		
		int array2[] = {1, 2, 3, 4}; // 값을 넣어서 초기화

1. 크기를 할당만 하고 값을 넣지 않고 배열을 생성
2. 배열을 생성함과 동시에 값을 넣어서 초기화

이 2가지 방법을 사용한다.


그렇다면 코틀린에서는 어떤 방법을 통해서 사용할 수 있을까?
코틀린에서 배열을 생성하는 법은 아래와 같다

fun main() {
    var array = arrayOfNulls<Int>(4);
    
    var array2 = arrayOf<Int>(1, 2, 3, 4);
}

첫 번째 배열 array 생성에서 크기만을 할당해서 생성하는 것은 똑같지만,
자바에서 위의 방식으로 생성하면 아래와 같은 결과가 나온다.

array : [0, 0, 0, 0]

하지만, 코틀린의 경우에는 아래 처럼 나오게 된다.

array : [null, null, null, null]

물론 코틀린에서도 Arrays.fill()함수를 사용하면 만들 수 있다.
자바와 같이 1로 초기화된 배열을 생성할 수 있다.

    Arrays.fill(array , 1);
    print("array : ${Arrays.toString(array)}")
    
    
    // 결과
    // array : [1, 1, 1, 1]


Kotlin 1차원 배열 생성


정수배열 생성

방법1

import java.util.*
private lateinit var arr : IntArray
fun main() {
    var N = 3
    arr = IntArray(N)

    println(Arrays.toString(arr))
} // End of main
[0, 0, 0]

방법2

import java.util.*
private lateinit var arr : Array<Int>
fun main() {
    var N = 3
    arr = Array(N, {0})

    println(Arrays.toString(arr))
} // End of main

위의 방법은 출력값은 "[0, 0, 0]"으로 동일하지만, 첫 번째 방법이 더 효율적이니 첫 번재 방법으로 기억하는게 좋음
참조 : https://toonraon.tistory.com/42


문자열 배열 생성

import java.util.*
private lateinit var arr : Array<String>
fun main() {
    var N = 3
    arr = arrayOf("A", "B", "C")
    println(Arrays.toString(arr))

    arr = Array(N, {"A"})
    println(Arrays.toString(arr))
} // End of main

// arr = arrayOf("A", "B", "C")
[A, B, C]

// arr = Array(N, {"A"})
[A, A, A]

비어있거나 Null값으로 배열 만들기

import java.util.*
private lateinit var arr : Array<String?>
fun main() {
    var N = 3
    arr = emptyArray()
    println(Arrays.toString(arr))

    arr = arrayOfNulls(N)
    println(Arrays.toString(arr))
} // End of main

// arr = emptyArray()
[]

// arr = arrayOfNulls(N)
[null, null, null]


Kotlin 2차원 배열 생성


이번에는 코틀린에서 2차원 배열을 생성하는 법이다.
코틀린에서 2차원 배열을 생성하는 법은 자바보다 훨씬 까다로웠다..

String (문자열 형) 2차원 배열 생성

import java.util.*
private lateinit var arr : Array<Array<String>>
fun main() {
    var N = 3
    arr = Array(N, {Array(N, {"a"})})

    arr.forEach {
        println(Arrays.toString(it))
    }
} // End of main
[a, a, a]
[a, a, a]
[a, a, a]

import java.util.*
private lateinit var arr : Array<Array<String>>
fun main() {
    var N = 3
    arr = arrayOf(
        Array(N, {"a"}),
        Array(N, {"a"}),
        Array(N, {"a"})
    )

    arr.forEach {
        println(Arrays.toString(it))
    }
} // End of main
[a, a, a]
[a, a, a]
[a, a, a]

Int (정수형) 2차원 배열 생성

import java.util.*

private lateinit var arr : Array<IntArray>
fun main() {
    var N = 3
    arr = Array(N){IntArray (N)}

    arr.forEach {
        println(Arrays.toString(it))
    }
} // End of main
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]

import java.util.*
private lateinit var arr : Array<IntArray>
fun main() {
    var N = 3
    arr = arrayOf(
        IntArray(N),
        IntArray(N),
        IntArray(N)
    )

    arr.forEach {
        println(Arrays.toString(it))
    }
} // End of main

IntArray(N)을 IntArray(N, {1})로 수정할 경우 , 값이 1로 초기화되어있는 배열을 만들 수 있습니다.

[0, 0, 0]
[0, 0, 0]
[0, 0, 0]


Ex) 첫째줄 IntArray(N, {1})일 경우
[1, 1, 1]
[0, 0, 0]
[0, 0, 0]


Kotlin에서 List 생성


우선 코틀린에서는 List가 2가지 종류로 나뉜다

1. 읽기전용 : List
2. 읽기 쓰기 모두 가능한 : MutableList

자바에서 생성되는 List는 MutableList 처럼 읽기 쓰기가 모두 가능하지만,
코틀린은 읽기만 가능한 List가 따로 있다.

아무래도 읽기만 가능한 List는 보안성이 훨씬 더 강조될 수 있고, 수정을 할 수 없으니 어떤 측면에서 보면 오류의 유발을 막을 수도 있다고 볼 수 있다.


읽기 전용 List

첫 번째 읽기 전용(readOnly) List는 처음 생성 이후로 값을 삽입 할 수없다.

즉, get은 가능하지만, set이나 add는 불가능하다.

    var list : List<Int> = listOf(1, 2, 3)
    
    list.add(1)

위 코드 처럼 List를 만들고, 값을 넣으려고 add를 실행했을 때 오류가 발생하는 것을 볼 수있다.

List의 내부문서로 들어가보면

실제로 get()을 제외하고는 set, add를 찾아볼 수 없음을 알 수 있다.

그렇다면 MutableList는 어떨까?


읽기 쓰기 모두 가능한 MutableList

MutableList로 들어가보면, add, remove, set을 모두 찾아볼 수 있다.


코드로 직접 한번 확인해보면 결과는 아래와 같다

    var muList : MutableList<Int> = mutableListOf(10, 20, 30);
    muList.add(40)
    muList.remove(20);
    
    println("muList : ${muList}")
    
    // 결과
    // muList : [10, 30, 40]

add, remove 모두 정상 작동하는 것을 볼 수 있다.

아무래도 Java를 사용하다가 Kotlin으로 넘어온 나는 MutableList가 훨씬 익숙한 감이 있어서 그런지 더 자주 사용할 것 같다.


Kotlin 인접리스트 생성


위에서 2차원배열인 행렬을 만들어 봤으니, 인접리스트가 빠지면 또 섭섭하다


인접 리스트


// 인접리스트 생성
private lateinit var list: MutableList<MutableList<Int>>

fun main() {
    var N = 2;
    var M = 2;

    // 노드의 개수 만큼 인접리스트 생성
    list = ArrayList()
    for(i in 0..N) {
        list.add(ArrayList())
    }

    var count = 0;
    for(i in 0..M) {
        list.get(i).add(count);
        count ++;
    }

} // End of main

인접 리스트 출력


    println(list)

    list.forEach {
        var it = it.iterator()
        it.forEach {
            println("${it}")
        }
    }
    
    
// 출력
[[0], [1], [2]]

0
1
2

이상 코틀린에서 배열과 리스트를 생성하는 법에 대해서 알아보았다.
2차원 배열은 확실히 자바가 더 직관적이고, 만들기도 쉬운 것 같다

리스트도 MutableList도 분리된게 조금 더 불편하달까

0개의 댓글