[Kotlin] Types

개요

이번 시간에는 코틀린의 타입에 대해서 알아보겠습니다.

---

Basic Types

코틀린은 기본 타입을 객체로 취급합니다. Java 와는 다르게 모든 것이 객체입니다.

---

Numbers

 

Integer Types

코틀린은 다양한 크기의 정수 타입을 제공합니다. 각 타입은 고정된 크기와 범위를 가지고 있습니다.

• Byte
  • 크기: 8비트
  • 범위: -128 ~ 127

val byteValue: Byte = 1

• Short
  • 크기: 16비트
  • 범위: -32,768 ~ 32,767

val shortValue: Short = 10

• Int
  • 크기: 32비트
  • 범위: -2^31 ~ 2^31-1

val intValue: Int = 100

• Long
  • 크기: 64비트
  • 범위: -2^63 ~ 2^63-1
  • 정수 리터럴은 기본적으로 Int 타입입니다. 더 큰 숫자를 표현하기 위해 Long 타입을 사용하려면 리터럴 끝에 L 을 붙입니다.

val longValue: Long = 1000L

---

Floating-point Types

• Float
  • 크기: 32비트
  • 유효 숫자: 약 6~7 자리
  • 부동 소수점 실수 리터럴은 기본적으로 Double 타입이기 때문에 Float 타입으로 사용하려면 리터럴 끝에 f 를 붙입니다.

val floatValue: Float = 10.0f

• Double
  • 크기: 64비트
  • 유효 숫자: 약 15~16자리

val doubleValue: Double = 10.0

---

Number Literals

코틀린은 다양한 형식의 숫자 리터럴을 지원합니다.

• 10진수 (Decimal)

val decimalValue = 123

• 16진수 (Hexadecimal)

val hexValue = 0x0F

• 2진수 (Binary)

val binaryValue = 0b00001011

---

숫자 타입 간 변환

코틀린에서는 명시적 변환 함수 (toByte(), toShort(), toInt(), toLong(), toFloat(), toDouble())를 사용하여 숫자 타입 간 변환을 수행합니다.

val intValue: Int = 1
val longValue: Long = intValue.toLong()

---

연산자 오버로딩

연산자 오버로딩이란 코틀린에서 연산자를 특정 클래스의 메서드로 처리할 수 있게 해주는 기능입니다. 이를 통해 클래스 인스턴스 간의 연산을 더 자연스럽게 표현할 수 있습니다. 

• 산술 연산자 (Arithmetic Operators)
  산술 연산자는 수학적 연산을 수행하는 데 사용됩니다. 예를 들어, + - * / 등이 있습니다.

data class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point): Point {
        return Point(x + other.x, y + other.y)
    }
}

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(3, 4)
    val result = p1 + p2
    println(result) // Point(x=4, y=6)
}

• 비교 연산자 (Comparison Operators)
  비교 연산자는 두 값을 비교하는 데 사용됩니다. 예를 들어, ==, !=, <, >, <=, >= 등이 있습니다.

data class Point(val x: Int, val y: Int)

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(1, 2)
    println(p1 == p2) // true
    println(p1 != p2) // false
}

data class Point(val x: Int, val y: Int) : Comparable<Point> {
    override operator fun compareTo(other: Point): Int {
        return (x * x + y * y) - (other.x * other.x + other.y * other.y)
    }
}

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(3, 4)
    println(p1 < p2) // true
}

• 할당 연산자 (Assignment Operators)
  할당 연산자는 값을 변수에 할당하는 데 사용됩니다. 예를 들어, +=, -=, *=, /= 등이 있습니다.

data class Point(var x: Int, var y: Int) {
    operator fun plusAssign(other: Point) {
        x += other.x
        y += other.y
    }
}

fun main() {
    var p1 = Point(1, 2)
    val p2 = Point(3, 4)
    p1 += p2
    println(p1) // Point(x=4, y=6)
}

• 인덱스 연산자 (Indexing Operators)
  인덱스 연산자는 배열이나 리스트처럼 인덱스로 접근하는 데 사용됩니다. get과 set 함수를 오버로딩할 수 있습니다.

class Matrix(private val rows: Int, private val cols: Int) {
    private val data = Array(rows) { IntArray(cols) }

    operator fun get(row: Int, col: Int): Int {
        return data[row][col]
    }

    operator fun set(row: Int, col: Int, value: Int) {
        data[row][col] = value
    }
}

fun main() {
    val matrix = Matrix(2, 2)
    matrix[0, 0] = 1
    println(matrix[0, 0]) // 1
}

• 호출 연산자 (Invoke Operator)
  호출 연산자는 객체를 함수처럼 호출할 수 있게 합니다. invoke 함수를 오버로딩합니다.

class Greeter {
    operator fun invoke(name: String) {
        println("Hello, $name!")
    }
}

fun main() {
    val greeter = Greeter()
    greeter("Kotlin") // Hello, Kotlin!
}

• 단항 연산자 (Unary Operator)
  • 단항 연산자는 하나의 피연산자에 대해 연산을 수행합니다. 예를 들어, +a, -a, !a, ++a, --a 등이 있습니다.
  • unaryPlus, unaryMinus, not 함수: +a, -a, !a 연산자를 오버로딩합니다.
  • inc, dec 함수: ++a, --a 연산자를 오버로딩합니다.

data class Point(val x: Int, val y: Int) {
    operator fun unaryMinus(): Point {
        return Point(-x, -y)
    }
}

fun main() {
    val p = Point(1, 2)
    val negativeP = -p
    println(negativeP) // Point(x=-1, y=-2)
}

---

Unsigned Integer Types

코틀린은 부호 없는 숫자 타입도 제공합니다. 부호 없는 타입은 모두 0 이상의 값을 가집니다.

• UByte
  • 크기: 8비트
  • 범위: 0 ~ 255
• UShort
  • 크기: 16비트
  • 범위: 0 ~ 65,535
• UInt
  • 크기: 32비트
  • 범위: 0 ~ 2^32-1
• ULong
  • 크기: 64비트
  • 범위: 0 ~ 2^64-1

---

숫자 리터럴 표기법

숫자 리터럴은 kotlin.text 패키지의 String.format 함수를 사용하여 형식을 지정할 수 있습니다.

val number = 1_000_000 // 읽기 쉽게 언더스코어 사용 가능
val formatted = String.format("%,d", number) // 1,000,000

---

특별한 값

• NaN: 숫자가 아닌 값
• POSITIVE_INFINITY: 양의 무한대
• NAGATIVE_INFINITY: 음의 무한대

위 값들은 부동소수점 연산에서 발생할 수 있는 특별한 값입니다.

val positiveInfinity = Double.POSITIVE_INFINITY
val negativeInfinity = Double.NEGATIVE_INFINITY
val notANumber = Double.NaN

---

Boolean Types

코틀린에서 Boolean 타입은 true 또는 false 두 가지 값을 가질 수 있습니다. 이 타입은 논리적 조건을 나타내는 데 사용됩니다.

 

Boolean Literal

boolean Literal 은 true 와 false 두 가지 값으로 표현됩니다.

val isTrue: Boolean = true
val isFalse: Boolean = false

 

Boolean Operator

코틀린에서는 Boolean 값을 조작하는 다양한 논리 연산자를 제공합니다.

• 논리 AND (&&)
• 논리 OR (||)
• 논리 NOT (!)

---

Characters

코틀린에서 Char 타입은 단일 문자를 나타냅니다. Char 리터럴은 작은따옴표로 묶습니다.

val letter: Char = 'A'

 

 

문자 리터럴

문자 리터럴은 작은따옴표로 묶이며, 단일 유니코드 문자를 포함할 수 있습니다.

val charA: Char = 'A'
val char1: Char = '1'
val charNewLine: Char = '\n' // 이스케이프 시퀀스

 

이스케이프 시퀀스

문자 리터럴에는 특수 문자를 나타내기 위한 이스케이프 시퀀스를 사용할 수 있습니다. 몇 가지 주요 이스케이프 시퀀스는 다음과 같습니다.

• \n: 새 줄
• \t: 탭
• \b: 백스페이스
• \r: 캐리지 리턴
• \': 작은따옴표
• \": 큰따옴표
• \\: 백슬래시
• \uFFFF: 유니코드 문자

문자와 숫자 간 변환

Char 타입은 유니코드 값으로 나타내어지므로, 이를 숫자 타입으로 변환할 수 있습니다.

val charA: Char = 'A'
val intA: Int = charA.toInt()
println(intA) // 65

 

 

반대로, 숫자 값을 Char 타입으로 변환할 수도 있습니다.

val intA: Int = 65
val charA: Char = intA.toChar()
println(charA) // 'A'

 

문자 연산

코틀린에서는 문자를 비교하거나 연산할 수 있습니다.

 

• 비교 연산

val a: Char = 'A'
val b: Char = 'B'
println(a < b) // true

• 산술 연산

val a: Char = 'A'
val b: Char = a + 1
println(b) // 'B'

fun main() {
    val charA: Char = 'A'
    val charNewLine: Char = '\n'
    val charUnicode: Char = '\u0041' // 'A'

    println("Character A: $charA")
    println("Character New Line: $charNewLine")
    println("Character Unicode A: $charUnicode")

    // Character to Int conversion
    val charB: Char = 'B'
    val intB: Int = charB.toInt()
    println("Int value of 'B': $intB")

    // Int to Character conversion
    val intC: Int = 67
    val charC: Char = intC.toChar()
    println("Character value of 67: $charC")

    // Character comparison
    val charX: Char = 'X'
    val charY: Char = 'Y'
    println("'X' < 'Y': ${charX < charY}") // true

    // Character arithmetic
    val charD: Char = 'D'
    val nextChar: Char = charD + 1
    println("Next character after 'D': $nextChar") // 'E'
}

 

---

Strings

코틀린에서 문자열은 불변 객체로, String 클래스로 표현됩니다. 문자열은 큰따옴표로 묶어 표현합니다.

val text: String = "Hello, Kotlin!"

 

문자열 리터럴

코틀린에서는 두 가지 유형의 문자열 리터럴을 지원합니다.

• 이스케이프 문자열 (Escaped String)
  
  • 이스케이프 문자열은 기존의 프로그래밍 언어와 마찬가지로 이스케이프 문자를 사용할 수 있는 문자열입니다.
  • 이스케이프 시퀀스의 예제는 Characters 문서의 내용을 참고하시기 바랍니다.
• 원시 문자열 (Raw String)
  • 원시 문자열은 삼중 따옴표로 묶으며, 여러 줄의 텍스트를 포함할 수 있습니다. 원시 문자열에서는 이스케이프 문자가 적용되지 않습니다.

val rawString = """
    fun main(args: Array<String>) {
        println("Hello, World!")
    }
"""

 

 

문자열 템플릿

코틀린은 문자열 템플릿을 지원하여 문자열 내에 변수와 표현식을 포함할 수 있습니다. 문자열 템플릿은 $ 기호를 사용하여 변수를 삽입하거나, ${} 안에 표현식을 삽입할 수 있습니다.

val name = "Kotlin"
val greeting = "Hello, $name!"
println(greeting) // Hello, Kotlin!

val a = 10
val b = 20
println("The sum of $a and $b is ${a + b}") // The sum of 10 and 20 is 30

 

문자열 연산

코틀린에서는 문자열에 대한 다양한 연산을 제공합니다. 

• 문자열 연결: 문자열을 + 연산자로 연결할 수 있습니다.

val firstName = "John"
val lastName = "Doe"
val fullName = firstName + " " + lastName
println(fullName) // John Doe

• 문자열 길이: length 속성을 사용하여 문자열의 길이를 얻을 수 있습니다.

val text = "Hello, Kotlin!"
println("Length of text is ${text.length}") // Length of text is 13

• 접근 연산자: 문자열의 특정 문자에 인덱스를 사용하여 접근할 수 있습니다.

val text = "Hello, Kotlin!"
val firstChar = text[0]
println(firstChar) // H

• 문자열 반복: repeat 함수를 사용하여 문자열을 반복할 수 있습니다.

val repeatedText = "Kotlin ".repeat(3)
println(repeatedText) // Kotlin Kotlin Kotlin

---

Arrays

코틀린에서 배열은 동일한 타입의 값을 저장할 수 있는 컨테이너입니다. 배열은 고정된 크기를 가지며, 인덱스를 사용하여 요소에 접근할 수 있습니다. 코틀린의 배열은 Array 클래스와 다양한 타입별 배열 클래스를 사용하여 생성됩니다.

 

배열 생성

코틀린에서 배열을 생성하는 방법에는 여러 가지가 있습니다.

• arrayOf

val intArray = arrayOf(1, 2, 3, 4, 5)
val stringArray = arrayOf("a", "b", "c")

• 특정 타입의 배열 생성 함수

val intArray = intArrayOf(1, 2, 3, 4, 5)
val doubleArray = doubleArrayOf(1.1, 2.2, 3.3)
val charArray = charArrayOf('a', 'b', 'c')

• Array 클래스 생성자

val array = Array(5) { i -> i * 2 } // [0, 2, 4, 6, 8]

 

배열의 요소 접근

배열의 요소에 접근하고 수정하는 방법은 다음과 같습니다.

val array = arrayOf(1, 2, 3, 4, 5)
val firstElement = array[0] // 첫 번째 요소에 접근
array[1] = 10 // 두 번째 요소를 10으로 변경

 

배열의 크기

배열의 크기는 size 속성을 사용하여 얻을 수 있습니다.

val array = arrayOf(1, 2, 3, 4, 5)
println(array.size) // 5

 

배열의 반복

배열의 요소를 반복하는 방법은 여러 가지가 있습니다.

• for loop

val array = arrayOf(1, 2, 3, 4, 5)
for (element in array) {
    println(element)
}

• forEach 함수

val array = arrayOf(1, 2, 3, 4, 5)
array.forEach { element ->
    println(element)
}

 

배열의 기타 함수

코틀린의 배열은 다양한 유용한 함수를 제공합니다.

 

• first, last: 배열의 첫 번째와 마지막 요소를 가져옵니다.

val array = arrayOf(1, 2, 3, 4, 5)
println(array.first()) // 1
println(array.last()) // 5

• filter: 조건에 맞는 요소만을 포함하는 새로운 배열을 반환합니다.

val array = arrayOf(1, 2, 3, 4, 5)
val evenArray = array.filter { it % 2 == 0 }
println(evenArray) // [2, 4]

• map: 각 요소에 주어진 변환 함수를 적용한 결과로 새로운 배열을 만듭니다.

val array = arrayOf(1, 2, 3, 4, 5)
val squaredArray = array.map { it * it }
println(squaredArray) // [1, 4, 9, 16, 25]

 

다차원 배열

코틀린은 다차원 배열을 지원합니다. 다차원 배열은 배열의 배열로 표현됩니다.

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

println(matrix[1][1]) // 5

 

Work with Arrays

• 변수 개수 인수 (vararg)를 함수에 전달
  • 코틀린에서는 vararg 매개변수를 사용하여 함수에 가변적인 수의 인수를 전달할 수 있습니다. 이는 인수의 개수를 사전에 알 수 없을 때 유용합니다. 배열을 vararg 매겨변수로 함수에 전달하려면, 스프레드 연산자를 사용하여 배열의 각 요소를 개별 인수로 전달할 수 있습니다.

fun main() {
    val lettersArray = arrayOf("c", "d")
    printAllStrings("a", "b", *lettersArray)
    // abcd
}

fun printAllStrings(vararg strings: String) {
    for (string in strings) {
        print(string)
    }
}

• 배열 비교
  • 두 배열이 동일한 순서로 동일한 요소를 가지고 있는지 비교하려면 contentEquals 와 contentDeepEquals 함수를 사용합니다.

val simpleArray = arrayOf(1, 2, 3)
val anotherArray = arrayOf(1, 2, 3)

// 배열의 내용 비교
println(simpleArray.contentEquals(anotherArray)) // true

// 요소를 변경 후 비교
simpleArray[0] = 10
println(simpleArray.contentEquals(anotherArray)) // false

• 배열 변환
  • 코틀린은 배열을 변환하는 다양한 유용한 함수를 제공합니다.
  • Sum
  • Shuffle

// sum 예제
val sumArray = arrayOf(1, 2, 3)
println(sumArray.sum()) // 6

// shuffle 예제
val simpleArray = arrayOf(1, 2, 3)
simpleArray.shuffle()
println(simpleArray.joinToString())

• 배열을 컬렉션으로 변환
  • 배열을 리스트나 세트로 변환하려면 toList 와 toSet 함수를 사용합니다.

val simpleArray = arrayOf("a", "b", "c", "c")
println(simpleArray.toSet()) // [a, b, c]
println(simpleArray.toList()) // [a, b, c, c]

val pairArray = arrayOf("apple" to 120, "banana" to 150, "cherry" to 90, "apple" to 140)
println(pairArray.toMap()) // {apple=140, banana=150, cherry=90}