#Numbers

Last modified: 05 May 2026

The Kotlin number types represent:

• Integer values (Byte, Short, Int, and Long)
• Floating-point values (Float and Double)

Use number types to store and process numeric data, for example, in arithmetic, counters, measurements, and other calculations.

#Choose a number type

In most cases, you can refer to the following rules to determine the correct number type for your task:

• Use Int for whole numbers.
• Use Long for whole numbers outside the Int range.
• Use Double for decimal numbers.
• Use Float when lower precision is acceptable or required.
• Use Byte and Short when an API or data format requires them.

Kotlin also provides Unsigned integer types as a Beta feature.

---

#Integer types

Kotlin provides four integer types with different sizes and value ranges:

#Declare integer values

Kotlin supports the following literal forms for integer values:

• Decimals: 123
• Hexadecimals: 0x0F
• Binaries: 0b00001011

Note: Kotlin does not support octal literals.

To declare a numeric value, specify the type explicitly:

kotlincopyval one: Int = 1

// Use underscores to improve readability
val oneBillion: Long = 1_000_000_000
val hexBytes: Int = 0xFF_EC_DE_5E
val bytes: Int = 0b11010010_01101001_10010100_10010010

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

You can also append the L suffix to declare a Long value:

kotlincopyval oneLong = 1L

When you declare a numeric type explicitly, the compiler checks that the value fits in the range of that type:

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

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

When you do not specify a numeric type, Kotlin infers Int if the value fits in the Int range. Otherwise, it infers Long:

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

If a value can be absent, use nullable types:

kotlincopyval maybeAbsent: Int? = null

---

#Floating-point types

For numbers with a fractional part, Kotlin provides Float and Double. These follow the IEEE 754 standard.

#Declare floating-point values

To declare a floating-point literal, include a decimal point (.) or use exponent notation:

kotlincopyval pi = 3.14
val avogadro = 6.02214076e23

By default, Kotlin infers floating-point literals as Double. To declare a Float, add the f or F suffix:

kotlincopyval pi = 3.14 // Double
val eFloat = 2.7182818284f // Float

---

#Arithmetic operations

Kotlin supports standard operators: +, -, *, /, and %.

kotlincopyprintln(1 + 2) // 3
println(2_500_000_000L - 1L) // 2499999999
println(3.14 * 2.71) // 8.5094
println(10.0 / 3) // 3.3333333333333335

#Integer division

Division between integer values always returns an integer result (the fractional part is discarded):

kotlincopyval intValue = 5 / 2 // result: 2
val longValue = 5L / 2 // result: 2

To return a floating-point result, make at least one operand a Float or Double.

---

#Type conversion

Numeric types are not subtypes of one another. Kotlin requires explicit conversions to avoid data loss.

#Conversion functions

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

Example:

kotlincopyval intValue: Int = 1
val doubleValue = intValue.toDouble() // 1.0

---

#Data overflow

If the result of an operation falls outside the type's range, overflow occurs.

#Overflow in operations

kotlincopyval intNumber: Int = 2147483647
println(intNumber + 1) // -2147483648 (wraps around)

#Narrowing conversions

Converting a large type to a smaller one may lose data:

kotlincopyval large: Int = 130
val narrowed: Byte = large.toByte() // -126

---

#Bitwise operations

Kotlin provides bitwise operations for Int and Long using infix functions:

• shl(bits) – signed shift left
• shr(bits) – signed shift right
• ushr(bits) – unsigned shift right
• and(bits) – bitwise AND
• or(bits) – bitwise OR
• xor(bits) – bitwise XOR
• inv() – bitwise inversion

---

#Floating-point number comparison

• Static types: Follows IEEE 754 (e.g., NaN == NaN is false).
• Generic/Nullable types: Uses equals() and compareTo().
• NaN is equal to itself.
• NaN is greater than POSITIVE_INFINITY.
• -0.0 is less than 0.0.

---

#Boxing and caching (JVM)

On the JVM, numbers are stored as primitives unless they are nullable or used in generics (boxed). The JVM caches boxed integers from -128 to 127.

• Within cache range: === (referential equality) may be true.
• Outside cache range: === will be false.
• Always use == for structural equality when comparing numeric values.