Основные типы

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

Kotlin предоставляет набор встроенных типов, представляющих числа.
Для целых чисел существуют четыре типа с различными размерами и, следовательно, диапазонами значений.

Все переменные, инициализированные целыми значениями, не превышающими максимального значения Int, имеют тип Int. Если начальное значение превышает это значение, то тип является Long. Чтобы явно указать Long значение, добавьте суффикс L к значению.

val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneLong = 1L // Long
val oneByte: Byte = 1

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

Для действительных чисел Kotlin предоставляет типы с плавающей точкой Float и Double. Согласно стандарту IEEE 754, типы с плавающей точкой различаются по своей точности, то есть по тому, сколько десятичных знаков они могут хранить. Float отражает одинарную точность IEEE 754, а Double обеспечивает двойную точность.

Вы можете инициализировать переменные типа Double и Float числами с дробной частью. Она отделена от целой части точкой (.) Для переменных, инициализированных дробными числами, компилятор определяет тип Double.

val pi = 3.14 // Double
// val one: Double = 1 // Error: type mismatch
val oneDouble = 1.0 // Double

Чтобы явно указать тип Float для значения, добавьте суффикс f или F. Если такое значение содержит более 6-7 десятичных знаков, оно будет округлено.

val e = 2.7182818284 // Double
val eFloat = 2.7182818284f // Float, actual value is 2.7182817

Обратите внимание, что в отличие от некоторых других языков, в Kotlin нет неявных расширений типов для чисел. Например, функция с параметром Double может быть вызвана только со значениями Double, но не Float, Int или другими числовыми значениями.

fun main() {
    fun printDouble(d: Double) { print(d) }

    val i = 1    
    val d = 1.0
    val f = 1.0f 

    printDouble(d)
//    printDouble(i) // Error: Type mismatch
//    printDouble(f) // Error: Type mismatch
}

Для преобразования числовых значений в разные типы используйте явные преобразования.

Литеральные константы

Существуют следующие виды литеральных констант для целочисленных значений:

• Десятичные: 123

  • Длинные числа отмечаются заглавной L: 123L

• Шестнадцатеричные: 0x0F

• Двоичные: 0b00001011

Kotlin также поддерживает стандартную запись для чисел с плавающей точкой:

• Вещественные числа по умолчанию: 123.5, 123.5e10

• Числа с плавающей точкой типа float отмечаются f или F: 123.5f

Можно использовать нижние подчеркивания для повышения читаемости числовых констант:

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

Представление чисел на JVM

На платформе JVM числа хранятся как примитивные типы: int, double, и так далее. Исключением являются случаи, когда вы создаете ссылку на число со значением null, например Int?, или используете обобщения. В этих случаях числа упаковываются в классы Java Integer, Double, и так далее.

Обратите внимание, что ссылки на одно и то же число со значением null могут быть разными объектами:

fun main() {
//sampleStart
    val a: Int = 100
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a
    
    val b: Int = 10000
    val boxedB: Int? = b
    val anotherBoxedB: Int? = b
    
    println(boxedA === anotherBoxedA) // true
    println(boxedB === anotherBoxedB) // false
//sampleEnd
}

Все ссылки на null-значения a на самом деле являются одним и тем же объектом из-за оптимизации памяти, применяемой JVM для Integer между -128 и 127. Она не применяется к ссылкам b, поэтому они являются разными объектами.

С другой стороны, они всё ещё равны:

fun main() {
//sampleStart
    val b: Int = 10000
    println(b == b) // Prints 'true'
    val boxedB: Int? = b
    val anotherBoxedB: Int? = b
    println(boxedB == anotherBoxedB) // Prints 'true'
//sampleEnd
}

Явные преобразования

Из-за разных представлений меньшие типы не являются подтипами больших. Если бы они были, у нас возникли бы проблемы следующего типа:

// Hypothetical code, does not actually compile:
val a: Int? = 1 // A boxed Int (java.lang.Integer)
val b: Long? = a // implicit conversion yields a boxed Long (java.lang.Long)
print(b == a) // Surprise! This prints "false" as Long's equals() checks whether the other is Long as well

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

Следовательно, меньшие типы не преобразуются неявно в большие. Это означает, что присвоение значения типа Byte переменной типа Int требует явного преобразования.

fun main() {
//sampleStart
    val b: Byte = 1 // OK, literals are checked statically
    // val i: Int = b // ERROR
    val i1: Int = b.toInt()
//sampleEnd
}

Все числовые типы поддерживают преобразования в другие типы:

• toByte(): Byte

• toShort(): Short

• toInt(): Int

• toLong(): Long

• toFloat(): Float

• toDouble(): Double

• toChar(): Char

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

val l = 1L + 3 // Long + Int => Long

Операции

Kotlin поддерживает стандартный набор арифметических операций над числами: +, -, *, /, %. Они объявлены как члены соответствующих классов.

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

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

fun main() {
//sampleStart
    val x = 5 / 2
    //println(x == 2.5) // ERROR: Operator '==' cannot be applied to 'Int' and 'Double'
    println(x == 2)
//sampleEnd
}

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

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

val x = (1 shl 2) and 0x000FF000

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

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

• Проверки на равенство: a == b и a != b

• Операторы сравнения: a < b, a > b, a <= b, a >= b

• Инициализация и проверки диапазонов: a..b, x in a..b, x !in a..b

Когда операнды a и b статически известны как Float или Double или их nullable аналоги (тип объявлен, выведен или является результатом умного приведения типов), операции над числами и формируемый ими диапазон следуют стандарту IEEE 754 для арифметики чисел с плавающей точкой.

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

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

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

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

Целые без знака

В дополнение к целым типам, Kotlin предоставляет следующие типы для целых чисел без знака:

• UByte: целое без знака 8 бит, диапазон от 0 до 255

• UShort: целое без знака 16 бит, диапазон от 0 до 65535

• UInt: целое без знака 32 бит, диапазон от 0 до 2^32 - 1

• ULong: целое без знака 64 бит, диапазон от 0 до 2^64 - 1

Типы без знака поддерживают большинство операций своих знаковых аналогов.

Литералы

Для упрощения работы с целыми числами без знака Kotlin предоставляет возможность маркировать целочисленный литерал суффиксом, указывающим конкретный тип без знака (аналогично Float или Long)

• u и U отмечают беззнаковые литералы. Точный тип определяется на основе ожидаемого типа. Если ожидаемый тип не указан, компилятор использует UInt или ULong в зависимости от размера литерала.

val b: UByte = 1u  // UByte, expected type provided
val s: UShort = 1u // UShort, expected type provided
val l: ULong = 1u  // ULong, expected type provided

val a1 = 42u // UInt: no expected type provided, constant fits in UInt
val a2 = 0xFFFF_FFFF_FFFFu // ULong: no expected type provided, constant doesn't fit in UInt

• uL и UL явно отмечают литерал как беззнаковый long.

val a = 1UL // ULong, even though no expected type provided and constant fits into UInt

Дополнительное обсуждение

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