Числа

Выбор числового типа

В большинстве случаев для выбора подходящего для вашей задачи числового типа можно руководствоваться следующими правилами:

• Используйте Int для целых чисел.

• Используйте Long для целых чисел, выходящих за пределы диапазона Int.

• Используйте Double для десятичных чисел.

• Используйте Float, если допустима или требуется меньшая точность.

• Используйте Byte и Short, если этого требует API или формат данных.

Целочисленные типы

В Kotlin есть четыре целочисленных типа с разными размерами и диапазонами значений:

val one: Int = 1

// Use underscores to improve readability
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

val oneLong = 1L

// Value fits in Byte
val oneByte: Byte = 1

// Error: the value does not fit in Byte
val tooBig: Byte = 128

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

val maybeAbsent: Int? = null

Типы с плавающей точкой

Для чисел с дробной частью в Kotlin предусмотрены типы Float и Double.

Типы с плавающей точкой соответствуют стандарту IEEE 754. Float обеспечивает одинарную точность. Double обеспечивает двойную точность.

Типы с плавающей точкой различаются размером и точностью:

val pi = 3.14
val avogadro = 6.02214076e23

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

val maybeAbsent: Double? = null

Арифметические операции

Kotlin поддерживает стандартные арифметические операции над числами: +, -, *, / и %.

Используйте эти операторы для выполнения распространенных вычислений:

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

Тип результата зависит от типов операндов. Подробнее см. в разделе Смешанные числовые выражения.

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

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

Преобразование типов

Числовые типы не являются подтипами друг друга. Чтобы избежать незаметной потери данных и неожиданного поведения, Kotlin требует явного преобразования типов.

Например, функция, ожидающая значение типа Double, не может принимать значение типа Int или Float без преобразования:

fun main() {
//sampleStart
    fun printDouble(x: Double) { 
        print(x) 
    }

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

    printDouble(x) // OK
    printDouble(xInt) // Error: argument type mismatch
    printDouble(xFloat) // Error: argument type mismatch
//sampleEnd
}

Все числовые типы поддерживают преобразование в другие числовые типы. Чтобы преобразовать число в другой тип, используйте явную функцию преобразования:

• toByte()

• toShort()

• toInt()

• toLong()

• toFloat()

• toDouble()

Например, следующий код преобразует значение типа Int в Double:

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

При преобразовании значения с плавающей точкой в целочисленный тип компилятор отбрасывает дробную часть:

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

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

val intNumber: Int = 1
val longNumber: Long = 1000
val result: Int = intNumber + longNumber 
// Error: Initializer type mismatch

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

fun main() {
    listOf(1, 2).log()
    // Int | Int
    
    listOf(1L, 2L).log()
    // Long | Long
    
    // Compiler interprets 1 as an ILT and resolves it to Long
    listOf(1, 2L).log()
    // Long | Long
    
    // .toInt() converts the literal to Int
    listOf(1.toInt(), 2L).log()
    // Int | Long
}
//sampleEnd

//sampleStart
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
}
//sampleEnd

fun main() {
//sampleStart
    val intValues: List<Int> = listOf(1, 2L)
    // Error: initializer type mismatch
//sampleEnd
}

Переполнение данных

Числовые типы могут представлять только значения в пределах определенных для них диапазонов.

Если результат операции выходит за эти пределы, происходит переполнение. При преобразовании значения в числовой тип меньшего размера преобразованное значение может отличаться от исходного.

Такое поведение может повлиять на результат выполнения кода, даже если компилятор его принимает.

fun main(){
//sampleStart
    val intNumber: Int = 2147483647
    // Max Int value is 2147483647
    println(intNumber + 1) // -2147483648
//sampleEnd    
}

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

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

    println(narrowed) // -126
//sampleEnd
}

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

Побитовые операции

В Kotlin доступны побитовые операции для Int и Long. Эти операции представлены набором инфиксных функций и inv().

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

К побитовым операциям относятся:

• shl() — знаковый сдвиг влево

• shr() — знаковый сдвиг вправо

• ushr() — беззнаковый сдвиг вправо

• and() — побитовое И

• or() — побитовое ИЛИ

• xor() — побитовое исключающее ИЛИ

• inv() — побитовая инверсия

Сравнение чисел с плавающей точкой

В Kotlin способ сравнения чисел с плавающей точкой зависит от статического типа операндов.

Если статически известно, что операнды имеют тип Float или Double, операции над числами и образуемый ими диапазон соответствуют стандарту IEEE 754 для арифметики с плавающей точкой.

Однако в обобщенных сценариях (например, при использовании Any, Comparable<...> или Collection<T>) поведение операндов, статический тип которых не является типом с плавающей точкой, отличается. В таких случаях Kotlin использует реализации equals() и compareTo() для Float и Double.

В результате:

• NaN считается равным самому себе

• NaN считается больше любого другого элемента, включая POSITIVE_INFINITY

• -0.0 считается меньше 0.0

В следующем примере показано различие между операндами со статическим типом числа с плавающей точкой и операндами, используемыми через обобщенные типы:

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

fun main() {
    // Operands statically typed as floating-point numbers
    println(Double.NaN == Double.NaN) // false
    println(0.0 == -0.0) // true

    // Operands used through a non-floating-point static type
    println(generalizedEquals(Double.NaN, Double.NaN)) // true
    println(generalizedEquals(0.0, -0.0)) // false
}
//sampleEnd  

Упаковка и кэширование чисел в JVM

В JVM значения числовых типов, допускающих значение null, обычно хранятся с использованием примитивных типов, таких как int, long или double. Однако при использовании обобщенных типов или числовых nullable-типов, например Int?, значение упаковывается и представляется в виде объекта.

JVM применяет к небольшим числам технику оптимизации памяти, кэшируя их упакованные представления. В результате упакованные числа с одинаковыми значениями могут быть ссылочно равны.

Например, JVM кэширует упакованные значения Integer в диапазоне от -128 до 127. Поэтому следующий код возвращает true:

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

Для значений за пределами кэшируемого диапазона упакованные значения являются отдельными объектами. В этом случае они не будут ссылочно равны, даже если их значения структурно равны. Поэтому для сравнения числовых значений используйте ==:

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

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