[Kotlin] Ch4-2. 배열

leeeha·2022년 9월 1일

코틀린

목록 보기

22/29

출처: https://www.boostcourse.org/mo234/lecture/154307?isDesc=false

배열 기본

배열이란?

데이터를 연속적으로 나열한 형태
arrayOf() 또는 Array() 생성자를 통해 배열을 생성
arrayOfNulls()는 비어있는 배열

val numbers = arrayOf(4, 5, 7, 3) // 정수형 
val animals = arrayOf("Cat", "Dog", "Lion") // 문자열형 
...
for(element in numbers) {
	println(element) 
}

cf) 배열은 객체로 생성되므로 동적 공간인 힙 메모리에 생성된다.

다차원 배열

다양한 자료형

배열 원소의 타입은 혼합해서 생성할 수 있다.

val mixArr = arrayOf(4, 5, 7, 3, "Chike", false) // 정수, 문자열, Boolean 혼합

cf) u는 unsigned를 의미함.

배열 요소에 접근

cf) iterator는 컬렉션에 저장되어 있는 요소들을 읽어오는 방법을 표준화한 인터페이스

val arr = intArrayOf(1, 2, 3, 4, 5)
println(arr.get(2)) // 게터로 접근 
println(arr[2]) // 연산자 오버로딩으로 대괄호로 접근 

val arr2d = arrayOf(arrayOf(1, 2, 3), arrayOf(4, 5, 6), arrayOf(7, 8, 9))
println(arr2d[2][1]) // 8 

arr.set(2, 7) // 인덱스 2번 요소를 값 7로 대체 
arr[0] = 8 
arr2d[2][1] = 2

package chap04.section2

import java.util.Arrays

fun main() {
    val arr = arrayOf(1, 2, 3, 4, 5)
    println(arr.get(2))
    println(arr[2])
    println(arr.size)

    for(ele in arr)
        print(ele)
    println()

    println(Arrays.toString(arr)) // 1차원 배열 출력하기 
    println(arr.contentToString())

    println(arr.sum())

    arr.set(1, 8)
    arr[1] = 6
    println(Arrays.toString(arr))
}

3
3
5
12345
[1, 2, 3, 4, 5][1, 2, 3, 4, 5]
15
[1, 6, 3, 4, 5]

package chap04.section2

import java.util.Arrays

fun main() {
	// 2차원 배열 출력하기 
    val array = arrayOf(intArrayOf(1, 2),
                        intArrayOf(3, 4),
                        intArrayOf(5, 6, 7))
    println(Arrays.deepToString(array))
    println(array.contentDeepToString())
}

[[1, 2], [3, 4], [5, 6, 7]]
[[1, 2], [3, 4], [5, 6, 7]]

배열의 메서드

배열 생성

val|var 변수명 = Array(요소 개수, 초기값)

ex1) 2씩 곱해지는 정수의 짝수 5개 (0, 2, 4, 6, 8)의 요소

val arr3 = Array(5, { i -> i * 2 }) 
println("arr3: ${arr3.contentToString()}")

arr3: [0, 2, 4, 6, 8]

ex2) 많은 양의 배열 생성

var a = arrayOfNulls<Int>(1000) // 1000개의 null로 채워진 정수 배열 
var a = Array(1000, { 0 }) // 1000개의 0으로 채워진 정수 배열

ex3) 객체 배열 생성

var a = Array(1000, { i -> myClass(i) })

배열 요소 추가 및 삭제

배열은 일단 정의되고 나면 고정되는 특징을 갖고 있다. 따라서, 배열을 새로 할당하는 방법으로 요소를 추가 및 삭제할 수 있다.

package chap04.section2

fun main() {
    val arr1 = intArrayOf(1, 2, 3, 4, 5)

    // 요소 추가
    val arr2 = arr1.plus(6)
    println("arr2: ${arr2.contentToString()}") // [1, 2, 3, 4, 5, 6]

    // 요소 삭제 (범위 내의 원소만 남기기)
    val arr3 = arr1.sliceArray(0..2)
    println("arr3: ${arr3.contentToString()}") // [1, 2, 3]
}

기타 배열 관련 API

package chap04.section2

fun main() { 
    // 배열 초기화
    val arr = Array(5){ it * 2 }
    for(ele in arr)
        print(ele)
    println()

    // 첫번째와 마지막 요소 확인
    println(arr.first())
    println(arr.last())

    // 값이 2인 원소의 인덱스 출력
    println("indexOf(2): ${arr.indexOf(2)}")

    // 배열 원소의 평균값 출력
    println("average: ${arr.average()}")

    // count에 의한 요소 개수
    println("count: ${arr.count()}")
    
    // 원소의 존재 여부 확인
    println(arr.contains(4))
    println(4 in arr)
    
    // 형식 매개변수로 자료형 제한
    val b = Array<Any>(10, {0}) 
    b[0] = "Hello World" 
    b[1] = 1.1 
    println(b.contentToString()) 
    // [Hello World, 1.1, 0, 0, 0, 0, 0, 0, 0, 0] 
}

배열의 순회

package chap04.section2

fun main() {
    val arr = intArrayOf(1, 2, 3, 4, 5)

    // 배열 원소 순회
    arr.forEach { element -> print("$element ") }
    println()

    // 각 원소에 대해 주어진 액션 수행
    arr.forEachIndexed { i, e -> println("arr[$i] = $e") }

    // 반복자 이용
    val it = arr.iterator()
    while(it.hasNext()){
        val e = it.next()
        print("$e ")
    }
}

이처럼 배열을 순회할 때는 for 루프 말고도 순환 메서드인 forEach, forEachIndexed 등을 사용할 수 있고 반복자인 Iterator를 사용할 수도 있다.

배열의 정렬

Array는 기본적인 정렬 알고리즘을 제공해준다. (기본은 오름차순)

정렬된 배열을 반환: sortedArray(), sortedArrayDescending()
원본 배열에 대한 정렬: sort(), sortDescending()

package chap04.section2

fun main() {
    val arr = arrayOf(8, 4, 3, 2, 5, 9, 1)

    // 정렬된 배열 반환
    val sortedArr = arr.sortedArray() // 오름차순
    println(sortedArr.contentToString()) // [1, 2, 3, 4, 5, 8, 9]

    val sortedArrDesc = arr.sortedArrayDescending() // 내림차순
    println(sortedArrDesc.contentToString()) // [9, 8, 5, 4, 3, 2, 1]

    // 원본 배열에 대한 정렬
    arr.sort(0, 4) // 0부터 size-1까지 부분적으로 정렬
    println(arr.contentToString()) // [2, 3, 4, 8, 5, 9, 1]

    arr.sortDescending()
    println(arr.contentToString()) // [9, 8, 5, 4, 3, 2, 1]

    // 컬렉션을 반환하는 경우
    val listSorted = arr.sorted()
    val listDesc = arr.sortedDescending()
    println(listSorted) // 내부적으로 toString() 실행됨. 
    println(listDesc)

    // sortBy를 이용해 특정 기준에 따라 정렬 
    val items = arrayOf("Dog", "Cat", "Lion", "Kangaroo", "Po")
    items.sortBy { item -> item.length } // 길이에 따라 오름차순 정렬
    println(items.contentToString()) // [Po, Dog, Cat, Lion, Kangaroo] 
}

package chap04.section2

data class Product(val name: String, val price: Double)

fun main() {
    val products = arrayOf(
        Product("Snowball", 870.00),
        Product("Smart Phone", 999.00),
        Product("Drone", 240.00),
        Product("Mouse", 333.56)
    )

    products.sortBy { it.price } // 오름차순 
    products.forEach { println(it) }
    
    products.sortByDescending { it.price } // 내림차순 
    products.forEach { println(it) }
}

Product(name=Drone, price=240.0)
Product(name=Mouse, price=333.56)
Product(name=Snowball, price=870.0)
Product(name=Smart Phone, price=999.0)

Product(name=Smart Phone, price=999.0)
Product(name=Snowball, price=870.0)
Product(name=Mouse, price=333.56)
Product(name=Drone, price=240.0)

package chap04.section2

fun main() {
    val products = arrayOf(
        Product("Snowball", 870.00),
        Product("Smart Phone", 999.00),
        Product("Drone", 240.00),
        Product("Mouse", 333.56),
        Product("Keyboard", 125.99),
        Product("Smart Phone B", 150.99),
        Product("Mouse", 512.89)
    )

    // (A) 두 객체의 가격을 비교하여 정렬 (p1이 크면 1, 같으면 0, 작으면 -1)
    products.sortWith(
        Comparator<Product> { p1, p2 ->
            when {
                p1.price > p2.price -> 1
                p1.price == p2.price -> 0
                else -> -1
            }
        }
    )
    
    /* 
      products.sortWith(
          Comparator { p1, p2 ->
              p1.price.compareTo(p2.price)
          }
      )
    */
    
    products.forEach { println(it) }

    // (B) compareBy 사용해 두 개의 속성에 의해 정렬 
    // 먼저 적은 속성이 우선순위가 더 높음. 
    // 이름이 같으면 가격을 기준으로 오름차순 
    products.sortWith(compareBy({it.name}, {it.price}))
    products.forEach { println(it) }

    // (C) 지정된 필드의 최솟값, 최댓값 구하기
    println(products.minOf {it.price}) 
    println(products.maxOf {it.price})
}

(A) sortWith
Product(name=Keyboard, price=125.99)
Product(name=Smart Phone B, price=150.99)
Product(name=Drone, price=240.0)
Product(name=Mouse, price=333.56)
Product(name=Mouse, price=512.89)
Product(name=Snowball, price=870.0)
Product(name=Smart Phone, price=999.0)

(B) compareBy
Product(name=Drone, price=240.0)
Product(name=Keyboard, price=125.99)
Product(name=Mouse, price=333.56)
Product(name=Mouse, price=512.89)
Product(name=Smart Phone, price=999.0)
Product(name=Smart Phone B, price=150.99)
Product(name=Snowball, price=870.0)

(C) minOf, maxOf
125.99
999.0

배열 원소 필터링

package chap04.section2

fun main() {
    val arr = arrayOf(1, -2, 3, 4, -5, 0)

    // 0보다 큰 원소만 출력
    arr.filter { e -> e > 0 }.forEach { e -> print("$e ") } // 1 3 4
    println()

    // 함수 체이닝
    val fruits = arrayOf("banana", "avocado", "apple", "kiwi")
    fruits
        .filter { it.startsWith("a") } // a로 시작하는 문자
        .sortedBy { it } // 알파벳 순으로 정렬
        .map { it.uppercase() } // 대문자로 변경
        .forEach { print("$it ") } // APPLE AVOCADO
    println()

    // when문을 사용한 요소 확인
    when{
        "apple" in fruits -> println("Apple!")
    }
}

다차원 배열 펼치기

package chap04.section2

fun main() {
    // 다차원 배열을 1차원 배열로 펼치기
    val numbers = arrayOf(1, 2, 3)
    val strs = arrayOf("one", "two", "three")
    val simpleArray = arrayOf(numbers, strs)
    simpleArray.forEach { println(it.contentToString()) }

    val flattenSimpleArray = simpleArray.flatten()
    println(flattenSimpleArray)
}