Skip to content

숫자 ​

Kotlin의 숫자 타입은 다음을 나타냅니다:

숫자 타입을 사용하여 산술 연산, 카운터, 측정값 및 기타 계산 등에서 숫자 데이터를 저장하고 처리할 수 있습니다.

숫자 타입 선택하기 ​

대부분의 경우 다음 규칙을 참고하여 작업에 적합한 숫자 타입을 결정할 수 있습니다:

  • 정수에는 Int를 사용합니다.
  • Int 범위를 벗어나는 정수에는 Long을 사용합니다.
  • 소수점이 있는 숫자(실수)에는 Double을 사용합니다.
  • 더 낮은 정밀도로 충분하거나 필요한 경우에는 Float를 사용합니다.
  • API나 데이터 포맷에서 요구할 때는 Byte와 Short를 사용합니다.

Kotlin은 베타 기능으로 부호 없는 정수 자료형도 제공합니다.

정수 타입 ​

Kotlin은 크기와 값의 범위가 서로 다른 네 가지 정수 타입을 제공합니다:

타입크기 (비트)최솟값최댓값
Byte8-128127
Short16-3276832767
Int32-2,147,483,648 (-231)2,147,483,647 (231 - 1)
Long64-9,223,372,036,854,775,808 (-263)9,223,372,036,854,775,807 (263 - 1)

정수 값 선언하기 ​

Kotlin은 정수 값에 대해 다음과 같은 리터럴 형식을 지원합니다:

  • 10진수: 123
  • 16진수: 0x0F
  • 2진수: 0b00001011

Kotlin은 8진수 리터럴을 지원하지 않습니다.

숫자 값을 선언할 때는 타입을 명시적으로 지정할 수 있습니다:

kotlin
val one: Int = 1

// 가독성을 높이기 위해 밑줄(underscore) 사용 가능
val oneBillion: Long = 1_000_000_000
val hexBytes: Int = 0x7F_EC_DE_5E
val bytes: Int = 0b01010010_01101001_10010100_10010010

val oneByte: Byte = 1
val oneShort: Short = 1

Long 값을 선언하기 위해 L 접미사를 붙일 수도 있습니다:

kotlin
val oneLong = 1L

숫자 타입을 명시적으로 선언하면 컴파일러는 값이 해당 타입의 범위에 맞는지 확인합니다:

kotlin
// Byte 범위에 맞는 값
val oneByte: Byte = 1

// 오류: Byte 범위에 맞지 않는 값
val tooBig: Byte = 128

숫자 타입을 명시하지 않으면 값이 Int 범위에 들어맞는 경우 Kotlin은 Int로 추론합니다. 그렇지 않으면 Long으로 추론합니다:

kotlin
val million = 1_000_000 // Int
val threeBillion = 3_000_000_000 // Long

값이 없을 수도 있는(null일 수 있는) 경우에는 널 가능 타입(nullable types)을 사용합니다:

kotlin
val maybeAbsent: Int? = null

부동소수점 타입 ​

소수 부분이 있는 숫자의 경우 Kotlin은 Float와 Double을 제공합니다.

부동소수점 타입은 IEEE 754 표준을 따릅니다. Float는 _단정밀도(single precision)_를 나타내며, Double은 _배정밀도(double precision)_를 나타냅니다.

부동소수점 타입은 크기와 정밀도에서 차이가 있습니다:

타입크기 (비트)유효 비트 수지수 비트 수10진수 자릿수
Float322486-7
Double64531115-16

부동소수점 값 선언하기 ​

부동소수점 리터럴을 선언하려면 소수점(.)을 포함하거나 지수 표기법을 사용합니다:

kotlin
val pi = 3.14
val avogadro = 6.02214076e23

기본적으로 Kotlin은 부동소수점 리터럴을 Double로 추론합니다. Float로 선언하려면 f 또는 F 접미사를 붙입니다:

kotlin
val pi = 3.14 // Double
val eFloat = 2.7182817f // Float

Kotlin은 Float에 저장할 수 있는 정밀도보다 더 많은 정밀도를 포함하는 Float 리터럴을 반올림합니다.

값이 없을 수도 있는 경우에는 널 가능 타입을 사용합니다:

kotlin
val maybeAbsent: Double? = null

산술 연산 ​

Kotlin은 숫자에 대한 표준 산술 연산인 +, -, *, /, %를 지원합니다.

이러한 연산자를 사용하여 일반적인 계산을 수행할 수 있습니다:

kotlin
fun main() {
    println(1 + 2) // 3
    println(2_500_000_000L - 1L) // 2499999999
    println(3.14 * 2.71) // 8.5094
    println(10.0 / 3) // 3.3333333333333335
}

결과 타입은 피연산자의 타입에 따라 결정됩니다. 자세한 내용은 혼합된 숫자 표현식에서 확인할 수 있습니다.

커스텀 숫자 클래스에서 이러한 연산자를 재정의할 수 있습니다. 자세한 내용은 연산자 오버로딩(Operator overloading)을 참고하세요.

정수 나눗셈 ​

정수 값 사이의 나눗셈은 항상 정수 결과를 반환합니다. 소수 부분은 컴파일러에 의해 버려집니다:

kotlin
fun main() {
    val intValue = 5 / 2
    println(intValue) // 2
    
    val longValue = 5L / 2
    println(longValue) // 2
}

부동소수점 결과를 얻으려면 피연산자 중 적어도 하나를 Float 또는 Double로 지정해야 합니다:

kotlin
fun main() {
    val a = 5 / 2.0
    println(a) // 2.5
    
    val b = 5 / 2.toDouble()
    println(b) // 2.5
}

타입 변환 ​

숫자 타입들은 서로 하위 타입(subtype) 관계가 아닙니다. Kotlin은 암시적인 데이터 손실과 예상치 못한 동작을 방지하기 위해 명시적인 변환을 요구합니다.

예를 들어, Double을 매개변수로 받는 함수는 변환 없이는 Int나 Float 값을 전달받을 수 없습니다:

kotlin
fun main() {
    fun printDouble(x: Double) { 
        print(x) 
    }

    val x = 1.0
    val xInt = 1
    val xFloat = 1.0f
    val one: Double = 1 // 오류: initializer type mismatch

    printDouble(x) // 정상
    printDouble(xInt) // 오류: argument type mismatch
    printDouble(xFloat) // 오류: argument type mismatch
}

모든 숫자 타입은 다른 숫자 타입으로의 변환을 지원합니다. 숫자를 다른 타입으로 변환하려면 명시적 변환 함수를 사용합니다:

  • toByte()
  • toShort()
  • toInt()
  • toLong()
  • toFloat()
  • toDouble()

예를 들어, 다음 코드는 Int 값을 Double로 변환합니다:

kotlin
fun main() {
    val intValue: Int = 1
    val doubleValue = intValue.toDouble()
    
    println(doubleValue) // 1.0
}

부동소수점 값을 정수 타입으로 변환할 때 소수 부분은 버려집니다:

kotlin
fun main() {
    val d: Double = 1.5
    val l: Long = d.toLong()
    
    println(l) // 1
}

혼합된 숫자 표현식 ​

Kotlin은 대입이나 함수 인자 전달 시 암시적 변환을 지원하지 않습니다. 하지만 산술 표현식에서는 서로 다른 숫자 타입을 결합하여 사용할 수 있습니다. 이러한 경우 Kotlin은 피연산자의 타입을 기반으로 결과 타입을 결정하며, 산술 연산자가 변환을 자동으로 처리합니다:

kotlin
val intNumber: Int = 1
val longNumber: Long = 1000
val result = intNumber + longNumber // 1001, Long

더 작은 크기의 타입에 결과를 대입하려고 하면 컴파일러 오류가 발생합니다:

kotlin
val intNumber: Int = 1
val longNumber: Long = 1000
val result: Int = intNumber + longNumber 
// 오류: Initializer type mismatch

정수 리터럴 타입 ​

타입 추론 과정에서 Kotlin은 주변 컨텍스트를 통해 특정 타입이 결정될 때까지 접미사가 없는 정수 리터럴을 특수한 정수 리터럴 타입(Integer Literal Type, ILT)으로 처리합니다:

kotlin
fun List<Any>.log() {
    println(joinToString(" | ") { it::class.simpleName ?: "Unknown" })
}

fun main() {
    listOf(1, 2).log()
    // Int | Int
    
    listOf(1L, 2L).log()
    // Long | Long
    
    // 컴파일러는 1을 ILT로 해석하고 Long으로 결정합니다
    listOf(1, 2L).log()
    // Long | Long
    
    // .toInt()는 리터럴을 Int로 변환합니다
    listOf(1.toInt(), 2L).log()
    // Int | Long
}

Int와 Long 값은 런타임에 문자열 표현이 동일하므로 특히 놓치기 쉽습니다. 이를 방지하려면 기대하는 타입을 명시하거나 값을 명시적으로 변환하세요:

kotlin
fun List<Any>.log() {
    println(joinToString(" | ") { it::class.simpleName ?: "Unknown" })
}

fun main() {
    val longValues: List<Long> = listOf(1, 2L)
    longValues.log()
    // Long | Long

    val numberValues: List<Number> = listOf(1.toInt(), 2L)
    numberValues.log()
    // Int | Long
}

명시적 타입을 사용하여 의도치 않은 타입 추론을 방지할 수도 있습니다:

kotlin
fun main() {
    val intValues: List<Int> = listOf(1, 2L)
    // 오류: initializer type mismatch
}

정수 리터럴 타입(Integer literal types)에 대해 자세히 알아보세요.

데이터 오버플로 ​

숫자 타입은 정의된 범위 내의 값만 표현할 수 있습니다.

연산 결과가 해당 범위를 벗어나면 오버플로(overflow)가 발생합니다. 값을 더 작은 숫자 타입으로 변환할 경우, 변환된 값은 원래의 숫자 값을 유지하지 못할 수 있습니다.

이러한 동작은 컴파일러가 허용하는 코드라 하더라도 실행 결과에 영향을 미칠 수 있습니다.

연산에서의 오버플로 ​

각 정수 타입은 정의된 범위 내의 값만 저장할 수 있습니다. 산술 연산의 결과가 해당 범위를 초과하면 _데이터 오버플로(data overflow)_가 발생합니다:

kotlin
fun main(){
    val intNumber: Int = 2147483647
    // Int의 최댓값은 2147483647
    println(intNumber + 1) // -2147483648
}

여기서 결과값이 Int에 더 이상 들어가지 않기 때문에 최솟값으로 순환(wrap around)됩니다.

정수 오버플로가 발생해도 컴파일러가 자동으로 오류를 발생시키지는 않습니다.

부호 반전에서의 오버플로 ​

부호 반전(negation) 중에도 오버플로가 발생할 수 있습니다. 예를 들어, Int.MIN_VALUE의 양수 대응값은 Int로 표현할 수 없습니다.

kotlin
fun main(){
    val min = Int.MIN_VALUE
    println(-min) // -2147483648
}

축소 변환 ​

값을 더 작은 정수 타입으로 변환할 때, 결과값에 원래의 숫자 값이 유지되지 않을 수 있습니다:

kotlin
fun main() {
    val large: Int = 130
    val narrowed: Byte = large.toByte()

    println(narrowed) // -126
}

반면, 부동소수점 타입은 IEEE 754 표준을 따르므로 매우 큰 결과값은 Infinity가 될 수 있습니다:

kotlin
fun main() {
    println(Double.MAX_VALUE * 2) // Infinity
}

비트 연산 ​

Kotlin은 Int와 Long에 대해 _비트 연산(bitwise operations)_을 제공합니다. 이러한 연산은 일련의 중위 함수(infix functions) 및 inv()로 표현됩니다.

kotlin
fun main() {
    val x = 1
    
    println(x shl 2) // 4
    println(x and 0x000FF000) // 0
}

비트 연산에는 다음이 포함됩니다:

  • shl() – 부호 있는 왼쪽 시프트(signed shift left)
  • shr() – 부호 있는 오른쪽 시프트(signed shift right)
  • ushr() – 부호 없는 오른쪽 시프트(unsigned shift right)
  • and() – 비트 단위 AND
  • or() – 비트 단위 OR
  • xor() – 비트 단위 XOR
  • inv() – 비트 반전

부동소수점 숫자 비교 ​

Kotlin에서 부동소수점 비교는 피연산자의 정적 타입에 따라 달라집니다.

피연산자가 정적으로 Float 또는 Double로 알려져 있는 경우, 해당 숫자들에 대한 연산 및 이들이 이루는 범위는 부동소수점 산술에 대한 IEEE 754 표준을 따릅니다.

그러나 제네릭 사용 사례(Any, Comparable<...>, 또는 Collection<T> 등)와 같이 피연산자의 정적 타입이 부동소수점 숫자가 아닌 경우에는 동작이 달라집니다. 이 경우 Kotlin은 Float와 Double에 대한 equals() 및 compareTo() 구현을 사용합니다.

이에 따라 다음과 같이 동작합니다:

  • NaN은 자기 자신과 같은 것으로 간주됩니다.
  • NaN은 POSITIVE_INFINITY를 포함한 다른 모든 요소보다 큰 것으로 간주됩니다.
  • -0.0은 0.0보다 작은 것으로 간주됩니다.

다음 예제는 정적으로 부동소수점 타입이 지정된 피연산자와 제네릭 타입을 통해 사용된 피연산자의 차이를 보여줍니다:

kotlin
fun generalizedEquals(a: Any, b: Any): Boolean {
    return a == b
}

fun main() {
    // 부동소수점 숫자로 정적 타입이 지정된 피연산자
    println(Double.NaN == Double.NaN) // false
    println(0.0 == -0.0) // true

    // 비부동소수점 정적 타입을 통해 사용된 피연산자
    println(generalizedEquals(Double.NaN, Double.NaN)) // true
    println(generalizedEquals(0.0, -0.0)) // false
}

JVM에서의 숫자 박싱 및 캐싱 ​

JVM에서 널 불가능(non-nullable) 숫자 값은 대개 int, long, double과 같은 원시 타입(primitive types)으로 저장됩니다. 하지만 제네릭 타입이나 Int?와 같은 널 가능 숫자 타입을 사용하면 값이 박싱(boxing)되어 객체로 표현됩니다.

JVM은 작은 숫자의 박싱된 표현을 캐싱하는 메모리 최적화 기법을 적용합니다. 그 결과, 동일한 값을 갖는 박싱된 숫자들이 참조 동등(referentially equal)할 수 있습니다.

예를 들어 JVM은 -128부터 127 범위의 박싱된 Integer 값을 캐싱합니다. 따라서 다음 코드는 true를 반환합니다:

kotlin
fun main() {
    val score: Int = 100
    val savedScore: Int? = score
    val displayedScore: Int? = score
    
    println(savedScore === displayedScore) // true
}

캐시 범위를 벗어나는 값의 경우, 박싱된 값은 서로 다른 객체가 됩니다. 이 경우 두 값은 구조적 동등(structurally equal)하더라도 참조 동등하지는 않습니다. 따라서 숫자 값을 비교할 때는 ==를 사용해야 합니다:

kotlin
fun main() {
    val score: Int = 10000
    val savedScore: Int? = score
    val displayedScore: Int? = score

    println(savedScore === displayedScore) // false
    println(savedScore == displayedScore) // true
}