[Kotlin] 코틀린 기본 문법 2 (배열의 모든 것)

개발하면서 배열은 정말 많이 사용됩니다.

코틀린에서 배열 사용 방법에 대해서 작성 해보겠습니다.

 

배열 선언과 초기화

Kotlin에서 배열을 선언하고 초기화하는 방법은 다음과 같습니다:

// 배열 선언
val numbers: Array<Int>

// 배열 초기화
numbers = arrayOf(1, 2, 3, 4, 5)

numbers[0] = 10
// [10, 2, 3, 4, 5]


// List 
val list: List<Int> = listOf(0, 1, 2)
print(list)
// [0, 1, 2]


list[0] = 10 // 오류 발생 !
list.set(0, 10) // 오류 발생 !

Array 는 값 변경 가능

List 는 immutable 이므로 위와 같이 값 변경이 안됨.

mutableListOf 로 선언하면 값 변경 가능.

    val list = mutableListOf<Int>(0, 1, 2)
    list[0] = 10
    print(list)
    // [10, 1, 1]
    
    list.set(2, 20)
    // [10, 1, 20]

 

초기화에 식 사용

val arr = Array<String>(5, {i -> "hello~${i+1}"})
arr.forEach{ println(it) }
/*
hello~1
hello~2
hello~3
hello~4
hello~5
*/

 

여러가지..

val arr01 = arrayOfNulls<String>(3)
val arr02 = emptyArray<String>()
val arr03 = intArrayOf(1, 2, 3)

val list01 = List<String>(3, {index -> "hello~ $index"})
val list02 = mutableListOf<String>("hello", "bryan", "bye")
val list03 = emptyList<String>()
val list04 = arrayListOf<String>("hello", "bryan", "bye")

 

Array 와 List 의 차이는 하단에 있어요

 

배열 요소 접근

Kotlin에서 배열의 각 요소에 접근하려면 인덱스를 사용합니다. 인덱스는 0부터 시작하여 배열의 크기보다 작은 값으로 지정됩니다.

val numbers = arrayOf(1, 2, 3, 4, 5)

// 배열 요소 접근
val firstElement = numbers[0]
val thirdElement = numbers[2]

 

배열 사이즈

val numbers = arrayOf(1, 2, 3, 4, 5)

// 배열 크기
val size = numbers.size

 

배열 순회

val numbers = arrayOf(1, 2, 3, 4, 5)

for (number in numbers) {
    println(number)
}

 

set()

val numbers = arrayOf(1, 2, 3, 4, 5)

// 배열의 인덱스 2 위치에 값 설정
numbers.set(2, 10)

// [1, 2, 10, 4, 5]

 

get()

val numbers = arrayOf(1, 2, 3, 4, 5)

// 배열의 인덱스 3 위치의 값 가져오기
val value = numbers.get(3)
// 4

getOrElse() : 기본값 가져오기

val numbers = arrayOf(1, 2, 3, 4, 5)

// 배열의 인덱스 10 위치의 값 가져오기
val value = numbers.getOrElse(10) { 0 }
// 0

 

원소 추가

var numbers = arrayOf(1, 2, 3, 4, 5)

numbers = numbers.plus(6)
// [1, 2, 3, 4, 5, 6]

var numbers = arrayOf(1, 2, 3, 4, 5)

numbers = numbers + 6
// [1, 2, 3, 4, 5, 6]

 

원소 제거

아래에서 사용한 it 는 키워드

var numbers = arrayOf(1, 2, 3, 4, 5)

numbers = numbers.filter { it != 3 }.toTypedArray()

ArrayList 사용하여 원소 추가 또는 삭제:

val numbers = arrayListOf(1, 2, 3, 4, 5)

numbers.add(6) // 원소 추가
numbers.remove(3) // 원소 삭제
// [1, 2, 4, 5, 6]

 

배열 요소 변경과 읽기 전용 배열

기본적으로 Kotlin의 배열은 가변(mutable)입니다. 

하지만 arrayOf() 함수 대신 arrayOfNotNull() 함수를 사용하여 읽기 전용(immutable) 배열을 생성할 수도 있습니다.

val readOnlyArray = arrayOfNotNull(1, 2, 3, 4, 5)
// readOnlyArray.set(1, 10) 사용 불가

 

reverse() : 배열의 순서 바꾸기

val numbers = arrayOf(1, 2, 3, 4, 5)

numbers.reverse()

// [5, 4, 3, 2, 1]

 

배열에 map 사용하기

val numbers = arrayOf(1, 2, 3, 4, 5)

val squaredNumbers = numbers.map { it * it }
// [1, 4, 9, 16, 25]

val names = arrayOf("Alice", "Bob", "Charlie")

val nameLengths = names.map { it.length }
// [5, 3, 7]

val fruits = arrayOf("apple", "banana", "orange")

val upperCaseFruits = fruits.map { it.toUpperCase() }
// ["APPLE", "BANANA", "ORANGE"]

data class Person(val name: String, val age: Int)

val people = arrayOf(Person("Alice", 25), Person("Bob", 30), Person("Charlie", 35))

val names = people.map { it.name }
// ["Alice", "Bob", "Charlie"]

val numbers = arrayOf(1, 2, 3, 4, 5)

val transformedNumbers = numbers.map { if (it % 2 == 0) "even" else "odd" }
// ["odd", "even", "odd", "even", "odd"]

 

참고

arrayOf

주로 사용되는 함수들

1. `get(index: Int): T`
   - 배열에서 주어진 인덱스에 해당하는 요소를 반환합니다.
   - 예시: `val value = array.get(0)`

2. `set(index: Int, value: T)`
   - 배열에서 주어진 인덱스에 요소를 설정합니다.
   - 예시: `array.set(0, value)`

3. `size: Int`
   - 배열의 요소 수를 반환합니다.
   - 예시: `val size = array.size`

4. `indices: IntRange`
   - 배열의 유효한 인덱스 범위를 나타내는 `IntRange` 객체를 반환합니다.
   - 예시: `for (i in array.indices) { ... }`
   - array가 [5,6,7,8] 이라면 i 는 0,1,2,3 으로 출력

5. `forEach(action: (T) -> Unit)`
   - 배열의 각 요소에 대해 주어진 동작을 수행합니다.
   - 예시: `array.forEach { println(it) }`

6. `forEachIndexed(action: (Int, T) -> Unit)`
   - 배열의 각 요소와 해당 인덱스에 대해 주어진 동작을 수행합니다.
   - 예시: `array.forEachIndexed { index, value -> println("Index: $index, Value: $value") }`
   - 예시: `array.forEachIndexed { i, v -> println("Index: $i, Value: $v") }`

7. `map(transform: (T) -> R): List<R>`
   - 배열의 각 요소를 주어진 변환 함수를 통해 변환한 결과를 가진 새로운 리스트를 반환합니다.
   - 예시: `val newList = array.map { it * 2 }`

8. `filter(predicate: (T) -> Boolean): List<T>`
   - 주어진 조건을 만족하는 배열 요소를 필터링하여 새로운 리스트로 반환합니다.
   - 예시: `val filteredList = array.filter { it > 5 }`

9. `plus(element: T): Array<T>`
   - 배열에 주어진 요소를 추가하여 새로운 배열을 반환합니다.
   - 예시: `val newArray = array.plus(10)`

10. `plus(elements: Array<out T>): Array<T>`
    - 배열에 주어진 다른 배열의 모든 요소를 추가하여 새로운 배열을 반환합니다.
    - 예시: `val newArray = array.plus(anotherArray)`

---

arrayListOf

주로 사용되는 함수들과 간단한 설명입니다:

1. `get(index: Int): E`
   - `ArrayList`에서 주어진 인덱스에 해당하는 요소를 반환합니다.
   - 예시: `val value = arrayList.get(0)`

2. `set(index: Int, element: E): E`
   - `ArrayList`에서 주어진 인덱스에 요소를 설정합니다.
   - 예시: `arrayList.set(0, value)`

3. `size: Int`
   - `ArrayList`의 요소 수를 반환합니다.
   - 예시: `val size = arrayList.size`

4. `isEmpty(): Boolean`
   - `ArrayList`가 비어 있는지 여부를 반환합니다.
   - 예시: `val empty = arrayList.isEmpty()`

5. `clear()`
   - `ArrayList`의 모든 요소를 제거합니다.
   - 예시: `arrayList.clear()`

6. `add(element: E): Boolean`
   - `ArrayList`에 요소를 추가합니다.
   - 예시: `val added = arrayList.add(value)`

7. `add(index: Int, element: E)`
   - `ArrayList`의 주어진 인덱스에 요소를 삽입합니다.
   - 예시: `arrayList.add(0, value)`

8. `remove(element: E): Boolean`
   - `ArrayList`에서 첫 번째로 일치하는 요소를 제거합니다.
   - 예시: `val removed = arrayList.remove(value)`

9. `removeAt(index: Int): E`
   - `ArrayList`에서 주어진 인덱스의 요소를 제거하고 반환합니다.
   - 예시: `val removedElement = arrayList.removeAt(0)`

10. `contains(element: E): Boolean`
    - `ArrayList`에 주어진 요소가 포함되어 있는지 여부를 반환합니다.
    - 예시: `val containsElement = arrayList.contains(value)`

또한 map, filter, forEach, forEachIndexed 사용 가능

 

---

 

List<T>와 ArrayList<T> 의 차이점

1. 인터페이스와 클래스:
   - List<T>: List는 인터페이스입니다. 읽기 전용 리스트를 나타내며, 요소의 추가, 수정, 삭제가 불가능합니다. 
   - ArrayList<T>: ArrayList는 List 인터페이스를 구현한 클래스입니다. ArrayList 는 가변 크기의 리스트 입니다.

2. 크기 조정:
   - List<T>: 크기가 고정되어 있어 요소의 추가, 수정, 삭제가 불가능합니다
   - ArrayList<T>: 가변 크기이므로 요소의 추가, 수정, 삭제가 가능합니다.

3. 메모리 할당:
   - List<T>: 변경 불가능한 리스트로 요소를 읽을 때 메모리를 절약할 수 있습니다. 읽기 전용인 경우 List 를 사용하는 것이 좋습니다.
   - ArrayList<T>: 가변 크기의 리스트가 필요한 경우 ArrayList 를 사용하는 것이 좋습니다.

4. 성능:
   - List<T>: 읽기 전용 리스트로서 요소의 변경이 없기 때문에 성능이 우수할 수 있습니다. 
   - ArrayList<T>: 가변 크기의 리스트로서 요소의 추가, 수정, 삭제 작업에 최적화되어 있으며, 빠른 성능을 제공합니다.

따라서,
List<T> 는 읽기 전용이나 변경 빈도가 낮은 경우에 적합하며,
ArrayList<T> 는 요소의 추가, 수정, 삭제가 빈번하게 발생하는 경우나 크기가 동적으로 조정되어야 하는 경우에 적합합니다. 

 

[Android] - [Kotlin] 코틀린 기본 문법 1 (변수, 자료형)

[Android] - [Kotlin] 코틀린 기본 문법 2 (배열의 모든 것)

[Android] - [Kotlin] 코틀린 기본 문법 3 (함수)

[Android] - [Kotlin] 코틀린 기본 문법 4 (조건문, 반복문)

[Android] - [Kotlin] 코틀린 기본 문법 5 (배열 응용)

[Android] - [Kotlin] findViewById 대신에 View binding