Kotlin - 배열

# 배열의 선언 및 접근

package chap02.section1


/* 배열의 선언 및 접근 */

import java.util.Arrays         // 배열을 사용하기 위해 자바 표준 라이브러리 임포트




fun main() {

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


    println("arr : ${arr.contentToString()}")       // 배열의 내용을 문자열로 반환
    println("size : ${arr.size}")                   // 배열의 크기
    println("sum() : ${arr.sum()}")                 // 배열의 합 계산

    // 게터에 의한 접근과 대괄호 연산자 표기법
    println(arr.get(2))
    println(arr[2])

    // 세터에 의한 값의 설정
    arr.set(2,7)
    arr[0] = 8
    println("size: ${arr.size} arr[0]: ${arr[0]}, arr[2]:${arr[2]}")

    // 루프를 통한 배열 요소의 접근
    for (i in arr.indices){
        println("arr[$i] = ${arr[i]}")
    }

    // 다차원 배열 선언 및 출력
    val arr2 = arrayOf(intArrayOf(1,2), intArrayOf(3,4), intArrayOf(5,6,7))
    println(arr2.contentDeepToString())

}

/**/

 

# 배열 제한하고 처리하기

package chap02.section1


/* */

import java.util.Arrays         // 배열을 사용하기 위해 자바 표준 라이브러리 임포트




fun main() {

    val arr1 = intArrayOf(1,2,3,4,5)        // 5개로 고정된 배열

    val arr2 = arr1.plus(6)         // 하나의 요소를 추가한 새 배열 생성
    println(arr2.contentToString())

    val arr3 = arr1.sliceArray(0..2)    // 필요한 범위를 잘라내서 새 배열 생성
    println(arr3.contentToString())

    println(arr1.first())           // 배열의 첫번째 값 출력
    println(arr1.last())            // 배열의 마지막 값 출력
    println(arr1.indexOf(4))        // 요소 4의 index 출력
    println(arr1.average())         // 배열의 평균 값 출력
    println(arr1.count())           // 배열의 개수 출력

    println(arr1.contains(100))     // arr1 배열에 값 100이 포함되어있는지 확인
    println(100 in arr1)            // arr1 배열에 값 100이 포함되어있는지 확인
    





}

# Any 자료형으로 지정된 배열 채우기

package chap02.section1


/* Any 자료형으로 지정된 배열 채우기 */

fun main() {


    val b = Array<Any>(10) { 0 }        // 처음에는 0으로 채워진 크기 10인 배열 선언
    b[0] = "Hello World"                    // 첫번째 값에 "Hello World" 할당 (String)
    b[1] = 1.1                              // 두번째 값에 1.1 할당 (double)

    println(b[0])
    println(b[1])
    println(b[2])



}

/* 이렇게 Any를 사용하면 한 번에 기본적인 초기화를 하고 나중에 원하는 자료형으로 요소를 초기화할 수 있으므로 편리하다.*/

 

# 멤버 메서드를 통한 배열 순환하기

package chap02.section1


/* 멤버 멤서드를 통한 배열 순환하기 */

fun main() {

    val arr1 = intArrayOf(1,2,3,4,5,6,7,8,9)

    arr1.forEach { element -> println("$element") }

    arr1.forEachIndexed { i, e -> println("arr[$i] = $e") }

    // iterator()를 사용한 요소 순환
    val iter : Iterator<Int> = arr1.iterator()
    while (iter.hasNext()){
        val e = iter.next()
        println("$e")
    }
    // hasNext()는 배열에서 참조할다음 요소가 있는지 확인하며, next()는 다음 요소를 반환하는 메서드이다.

}

 

# 배열 정렬하기

package chap02.section1

import java.util.Arrays

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


/* 기본적인 배열 정렬 방법 */
fun main() {

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


    val sortedNums = arr.sortedArray()                          // 오름차순으로 정렬된 배열 반환
    println("ASC : " + sortedNums.contentToString())

    val sortedNumsDesc = arr.sortedArrayDescending()            // 내림차순으로 정렬된 배열 반환
    println("DEC : " + sortedNumsDesc.contentToString())

    // 원본 배열에 대한 정렬
    arr.sort(1,3)                                               // sort(fromIndex,toIndex)
    println("ORI : " + arr.contentToString())
    arr.sortDescending()
    println("ORI : " + arr.contentToString())

    // List로 반환
    val listSorted : List<Int> = arr.sorted()
    val listDesc : List<Int> = arr.sortedDescending()
    println("LST : $listSorted")
    println("LST : $listDesc" )

    // SortBy를 이용한 특정 표현식에 따른 정렬
    val items = arrayOf<String>("Dog","Cat","Lion","Kangaroo","Po")
    items.sortBy { item -> item.length }
    println(items.contentToString())

    val products = arrayOf(
        Product("Snow ball",870.00),
        Product("Smart Phone",999.00),
        Product("Drone",240.00),
        Product("Mouse",333.55),
        Product("Keyboard",125.99),
        Product("Monitor",1500.99),
        Product("Table",512.99))

    products.sortBy { it.price }                // 배열 객체인 products를 it으로 넘기고 제품의 가격인 price가 제일 낮은 것을 기준으로 정렬
    products.forEach { println(it) }










}

# Comparator, compareBy()

package chap02.section1

import java.util.Arrays

/* Comparator를 사용해 제품 비교하기 */

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

fun main() {

    val products = arrayOf(
        Product("Snow ball",870),
        Product("Smart Phone",999),
        Product("Drone",240),
        Product("Mouse",644),
        Product("Keyboard",126),
        Product("Smart Phone B",1501),
        Product("Mouse",513))

    /* Comparator 사용
    products.sortWith(
        Comparator<Product> { p1, p2 ->
            when {
                p1.price > p2.price -> 1
                p1.price == p2.price -> 0
                else -> -1
            }
        }
    )
    products.forEach { println(it) }*/

    /* compareBy() 사용 */
    products.sortWith(compareBy({it.name},{it.price}))
    products.forEach { println(it) }

}

/* Comparator는 자바의 인터페이스로서 2개의 객체를 비교하는 compare()를 구현한다.
    여기서는 람다식 p1,p2 -> when {...}을 이용해 비교 결과가 p1이 p2보다 크면 1을, 같으면 0, 작으면 -1을 반환하도록 구현되어 있다.
    여기에 다시 compareBy()를 함께 사용하면 이름을 먼저 정렬하고 그 다음 이름이 동일한 경우 가격 기준으로 다시 정렬한다.
* */

 

# 배열 필터링하기(메서드 체이닝) - Method Chaining

package chap02.section1

/* 필요한 정보만 골라내어 변경하기 */


fun main() {

    val fruits = arrayOf("banana","avocado","apple","kiwi")
    fruits
        .filter { it.startsWith("a") }
        .sortedBy { it }
        .map { it.toUpperCase() }
        .forEach { println(it) }
}

/* 배열 객체 변수인 fruits에서 여러 개의 메서드인 filter(), sortedBy(), map(), forEach()를 계속 연속해서 
* 호출하는 방법을 메서드 체이닝이라고 한다. 각 결과를 it으로 넘겨받아 처리할 수 있어 매우 유용하다.
*  */

 

# 단일 배열로 변환

package chap02.section1

/* 2차원 배열 평탄화하기 */


fun main() {

    val numbers = arrayOf(1,2,3)
    val strs = arrayOf("one","two","three")
    val simpleArray = arrayOf(numbers,strs)     // 2차원 배열

    simpleArray.forEach { println(it) }
    println(simpleArray.contentDeepToString())

    val flattenSimpleArray = simpleArray.flatten()      // 단일 배열로 변환하기
    println(flattenSimpleArray)


}