코틀린을 사용하다보면 분명히 List 와 Array 두 자료구조의 공존에 있어 의구심을 품을 수 있다!
대체 뭐가 다르길래 구분지어져 있대? 🤔 하는 분들을 위해 이 포스팅을 바친다.

동적 자료구조, List

내부 구현

내부적으로 MutableList 를 List 인터페이스에 캐스팅하여 사용함

public interface List<out E> : Collection<E> {
    // Query Operations

    override val size: Int
    override fun isEmpty(): Boolean
		.
		.
		.
    public fun indexOf(element: @UnsafeVariance E): Int
    public fun lastIndexOf(element: @UnsafeVariance E): Int
    public fun listIterator(): ListIterator<E>
    public fun listIterator(index: Int): ListIterator<E>
    public fun subList(fromIndex: Int, toIndex: Int): List<E>
}

List 의 특징

• 순서가 있는 자료형들의 집합 (시퀀스)
• 불연속적인 메모리 공간을 점유하여 메모리 관리에 용이함 → 포인터로 값을 접근함
• List 에서 인덱스라 함은, '몇 번째 데이터인가' 정도의 의미를 갖게 됨
• listOf , mutableListOf() 등과 함께 리스트를 생성할 수 있음
• List 는 Null 을 포함할 수 있고, 중복 요소를 허용함
• 만일 두 리스트가 서로 원소들의 인덱스, 내용이 모두 같으면 같은 리스트로 간주함

val bob = Person("Bob", 31)
val people = listOf(Person("Adam", 20), bob, bob)
val people2 = listOf(Person("Adam", 20), Person("Bob", 31), bob)
println(people == people2)  // true
bob.age = 32
println(people == people2)  // false

1. Immutable List → 내용을 바꿀 수 없는 리스트

val school = listOf("mackerel", "trout", "halibut")
println(school)

// [mackerel, trout, halibut]

2. Mutable List → 내용을 자유자재로 바꿀 수 있는 리스트

val myList = mutableListOf("tuna", "salmon", "shark")
myList.remove("shark")

// res36: kotlin.Boolean = true

val numbers = mutableListOf(1, 2, 3, 4)
numbers.add(5)
numbers.removeAt(1)
numbers[0] = 0
numbers.shuffle()
println(numbers)

*이때 true 를 출력하는 이유는 remove() 메소드가 원소 삭제 성공 여부를 리턴하기 때문

List 의 장점

• 포인터를 사용하여 다음 값을 가르키고 있기 때문에 삽입과 삭제 동작이 빠름
• 동적 타입이기 때문에 크기가 정해져있지 않아 자유자재로 사용 가능
• 메모리의 재사용이 용이함

List 의 단점

• 불연속적 메모리 공간을 사용하는 만큼, 검색 성능은 좋지 않음
• 포인터를 통해 다음 값을 가르키므로 포인터를 담기 위한 추가적인 메모리 공간이 필요함

정적 데이터 타입, Array

내부 구현

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ...
}

Array 의 특징

• Array 는 생성한 순간, 사이즈는 고정되며 원소 삭제나 추가 등을 사용할 수 없음
• 대신 그 안에서의 원소 값 변경은 자유롭게 할 수 있음
• 코틀린에서는 따로 mutableArray 이런 게 있는게 아니라 기본적으로 Mutable 동작을 함
• 따라서 val 으로 선언하나 var 으로 선언하나 똑같은 동작을 함
• arrayOf 키워드를 통해 선언할 수 있음 (출력 시 java.util.Arrays.toString() 사용)

val school = arrayOf("shark", "salmon", "minnow")
println(java.util.Arrays.toString(school))

// [shark, salmon, minnow]

• 또한, 서로 다른 타입이 공존할 수 있음

val mix = arrayOf("fish", 2)

• Array 끼리 합치는 동작도 가능

val numbers = intArrayOf(1, 2, 3)
val numbers3 = intArrayOf(4, 5, 6)
val foo2 = numbers3 + numbers
println(foo2[5])  // 3

• Array 와 List 를 합친 새로운 중첩 List 를 생성하는 것도 가능

val numbers = intArrayOf(1, 2, 3)
val oceans = listOf("Atlantic", "Pacific")
val oddList = listOf(numbers, oceans, "salmon")
println(oddList)

// [[I@89178b4, [Atlantic, Pacific], salmon]

*첫 번째 원소의 경우 Array 인데, Array 를 출력하는 Array Utility 를 사용하지 않으면
코틀린은 해당 Array 의 주소만을 출력함

• Array 생성 시 아래와 같은 간단한 초기화 작업도 가능함

// [0, 2, 4, 6, 8] 형태의 Array<Int> 생성
val array = Array (5) { it * 2 }
println(java.util.Arrays.toString(array))

// ["0", "1", "4", "9", "16"] 형태의 Array<String> 생성
val asc = Array(5) { i -> (i * i).toString() }
asc.forEach { println(it) }

*자동으로 생성된 it 키워드는 Array 의 Index 역할을 함

• 만약 Primitive 타입만 담는다면, 다음과 같이 선언해주면 됨 (아니, 선언해야 함)

val numbers = intArrayOf(1,2,3)

// Array of int [0, 0, 0, 0, 0]
val arr = IntArray(5)

// [42, 42, 42, 42, 42]
val arr = IntArray(5) { 42 }

// [0, 1, 2, 3, 4]
var arr = IntArray(5) { it * 1 }

이런식으로 Primitive Type Array 를 사용하면 Boxing Overhead 를 피할 수 있음
신기하게 Array 클래스와 상속관계는 없음. 그러나 메소드나 프로퍼티는 동일함!

다만 명백히 Array<Int> 는 자바의 Integer[] 와 매핑되고,
IntArray 는 자바의 int[] 에 매핑되기 때문에 Overhead 방지를 위해 꼭 구분지어 사용할 것!

장점

• 인덱스를 통한 검색이 용이함
• 연속된 메모리 공간을 사용하여 메모리 관리가 편리함

단점

• 배열에거 값을 삭제해도 크기가 줄어들지 않기 때문에 메모리가 낭비된다고 볼 수 있음
• 배열은 정적 데이터 타입이므로 배열 크기를 컴파일 이전에 지정해줘야 하는 번거로움이 있음
• 배열의 크기를 이후에 재조정할 수 없기 때문에 사용하기 까다로움

List 와 Array 의 핵심 차이점

1. Array 는 무조건 고정된 사이즈를 가짐 (고정된 연속 메모리 내에서 원소를 저장)
   반면 List 는 사이즈를 변형할 수 있음 (불연속적인 메모리 공간을 가져 메모리 관리에 용이)

2. IntArray, ByteArray 등 Primitive 타입에 매핑되는 자료형을 제공하는 Array 와 다르게
   일반적인 경우 List 는 Primitive 타입에 최적화된 (매핑되는) 구현이 존재하지 않음
   (JDK 외부 라이브러리 중 이를 제공하는 라이브러리가 있긴 함)

3. List 와 다르게 Array 는 동등성 비교를 지원하지 않음
   즉, Array 의 경우 구성 원소의 인덱스와 값이 모두 같아도 false 를 리턴함

4. JVM 차원에서 봤을 때 Array 는 arrays 를 말하고, List 는 java.util.List 를 말함

---

한 마디로 말해, Array 는 처음부터 고정된 크기를 갖고 List 는 이와 다르게 동적으로 활용할 수 있다는 점이 가장 큰 차이점이다. 이제부터는 이 둘의 차이점을 명백히 알고 사용하도록 하자!