[TIL] #5 Kotlin Basic Syntax 3

💡 Array

• 여러 개의 데이터를 담을 수 있는 대표적인 자료형
• 배열의 크기는 생성 시 지정하며, 이후에 크기를 변경할 수 없음
• 대표적인 기본 자료형(Int, Double, Float, Char 등)과 getter, setter를 지원함

// 정수형 배열 선언
val intArray: Array<Int> = arrayOf(1, 2, 3, 4, 5)

// 문자열 배열 선언
val stringArray: Array<String> = arrayOf("apple", "banana", "orange")

• 배열은 인덱스를 사용하여 개별 요소에 접근할 수 있음

val firstElement = intArray[0] // 첫 번째 요소에 접근
intArray[2] = 10 // 세 번째 요소 값을 변경

---

💡 Collection

• 배열과 달리 크기를 자유롭게 조절할 수 있음
• List, Set, Map가 있음

1. List

• 순서가 있음
• 중복 요소 허용
• listOf() 함수로 생성

val myList: List<Int> = listOf(1, 2, 3, 4, 5)

• 인덱스를 사용하여 개별 요소에 접근할 수 있음
  • 단, immutable 속성을 가지므로 요소를 추가하거나 변경할 수 없음

2. Set

• 순서가 없음
• 중복 요소 허용하지 않음
• setOf() 함수로 생성

val mySet: Set<String> = setOf("apple", "banana", "orange")

3. Map

• 순서가 없음
• 키-값(key-value) 쌍
• 키는 중복될 수 없음
• mapOf() 함수로 생성

val myMap: Map<String, Int> = mapOf("one" to 1, "two" to 2, "three" to 3)

• 특정 키를 사용하여 값을 검색할 수 있음

val valueOfTwo = myMap["two"] // 2를 반환

4.Mutable vs Immutable

1) Mutable Collection

• 요소를 추가, 제거, 변경하는 등의 작업을 할 수 있음
• 동적인 데이터 조작이 가능하며, 프로그램 실행 중에 요소들을 변경할 수 있음
• MutableList, MutableSet, MutableMap 등과 같은 클래스로 표현

// Mutable List
val mutableList: MutableList<Int> = mutableListOf(1, 2, 3)
mutableList.add(4) // 리스트에 4를 추가
mutableList.removeAt(0) // 첫 번째 요소를 제거

// Mutable Set
val mutableSet: MutableSet<String> = mutableSetOf("apple", "banana", "orange")
mutableSet.add("kiwi") // 세트에 "kiwi"를 추가
mutableSet.remove("banana") // "banana" 요소를 제거

// Mutable Map
val mutableMap: MutableMap<String, Int> = mutableMapOf("one" to 1, "two" to 2, "three" to 3)
mutableMap["four"] = 4 // 맵에 "four" 키와 4 값을 추가
mutableMap.remove("one") // "one" 키와 해당 값 제거

2) Immutable Collection

• 한 번 생성되면 요소를 수정할 수 없음
• 변경이 필요 없는 경우에 유용
• 데이터 불변성을 유지하는데 도움이 됨
• List, Set, Map 등과 같은 인터페이스를 구현한 클래스들로 표현

// Immutable List
val immutableList: List<Int> = listOf(1, 2, 3)

// Immutable Set
val immutableSet: Set<String> = setOf("apple", "banana", "orange")

// Immutable Map
val immutableMap: Map<String, Int> = mapOf("one" to 1, "two" to 2, "three" to 3)

---

💡 Single-Expression Function

• 한 줄의 식(Expression)으로 간단하게 함수를 정의하는 방법
• 단일 표현식 함수는 중괄호{}를 둘러싸지 않아도 됨
• 단일 표현식 함수를 사용하면 더 간단하고 가독성이 높아짐
  • 특히 간단한 계산이나 변환 등의 작업에 유용
• 단순한 경우에 유용하며, 함수 본문이 복잡해지는 경우에는 여전히 일반적인 방식을 사용하는 것이 바람직함
• 반환값은 표현식의 결과로 자동으로 결정됨
• 함수 반환값이 명시적으로 지정 되어있는 경우, 콜론: 뒤에 반환 타입을 명시해주어야 함
  • 반환 타입은 표현식의 결과에 의해 자동으로 유추되기도 하지만, 코드의 가독성을 위해 명시적으로 지정해주는 것이 좋음

// 일반적인  함수
fun add(a: Int, b: Int): Int {
    return a + b
}


// Single-Expression Function
fun add(a: Int, b: Int): Int = a + b

// 일반적인 함수 정의
fun getMax(a: Int, b: Int): Int {
    return if (a > b) a else b
}

// Single-Expression Function
fun getMax(a: Int, b: Int): Int = if (a > b) a else b

---

💡 Singleton

• 어떤 클래스의 인스턴스는 오직 하나임을 보장하며, 이 인스턴스는 전역에서 접근할 수 있는 디자인 패턴
• 어플리케이션의 시작과 종료까지 한 번의 생성으로 고정된 메모리 영역을 가지므로, 메모리를 효율적으로 사용할 수 있음

1. object

• 클래스 외부에서 선언
• object로 선언된 클래스는 별도의 객체 생성 없이 바로 호출할 수 있음
• object를 초기화 하기 위해서는 init블록을 사용하며 처음에만 실행됨
• object 내에 선언된 속성과 함수는 클래스명.(함수/필드)로 호출이 가능함

object Math {
    fun sum(vararg args: Int): Int {
        var result = 0
        for (num in args) {
            result += num
        }
        
        return result
    }
}

fun main() {
    println(Math.sum(1, 2, 3))
}


// output
// 6

• object 표현식

open class Man {
    open fun fly() {
        println("I Can't Fly")
    }
}

fun main() {
    val superman = object : Man() {
        override fun fly() {
            println("I Can Fly")
        }
    }

    superman.fly()
}


// output
// I Can Fly

2. companion object

• 클래스 내부에서 선언
• companion object로 생성한 파라미터가 있는 싱글톤 클래스는 객체를 생성할 수 있음
• 상속 관계에서 companion 멤버는 가려짐

• 여러 개의 이름이 다른 객체를 생성할 수 있지만, 클래스의 메모리 주소값은 동일함
• companion object 내에 선언된 속성과 함수는 클래스명/객체명.(함수/필드)로 호출이 가능함

class Parent {
    companion object {
        fun action() {
            println("Parent")
        }
    }
}

class Child {
    companion object {
        fun action() {
            println("Child")
        }
    }
}

fun main() {
    Parent.action()
    Child.action() // Child Companion Object의 action을 호출
    Child.Companion.action() // 객체 처럼 사용
}


// output
// Parent
// Child
// Child

• 이름이 있는 companion object

class Base {
    // companion object에 이름 붙이기
    companion object Test {
        fun action() {
            println("Base Test")
        }
    }
}

fun main() {
    Base.Test.action()
    Base.action()   // 이름을 생략하여 호출 가능
}


// output
// Bast Test
// Base Test

3. const val

• 상수 표현식으로 primitive type과 String형에만 사용가능
• 컴파일 시간에 상수처리를 하는 표현식
• object, companion object, main 함수 밖에만 사용할 수 있음

const val start = 0
const val end = 5

fun main() {
    for(i in start..end) {
        println(i)
    }
}


// output
// 0
// 1
// 2
// 3
// 4
// 5

---

[참고 사이트]

'코틀린(Kotlin)에서 배열(Array)과 리스트(List)의 비교', Youjourney Blog
'코틀린 기초 (3) - 함수', hudi.blog
'[Kotlin] Koltin의 싱글톤 패턴(Singleton Pattern)', 준영;한 개발자
'Kotlin in A..Z (18) - companion object, object, 싱글톤', 개발일지