Data Types

Christine_Yang's avatar
Christine_Yang's avatar
Christine_Yang
Published Jan 17, 2023Updated Apr 2, 2025
Contribute to Docs

Data types classify values in Kotlin and determine the operations that can be performed on them.

Unlike some languages, Kotlin does not have primitive data types. All data types in Kotlin are objects. However, for performance reasons, the Kotlin compiler may internally optimize certain types using JVM primitives.

Primitive Data Types

There are the following different types of primitive data types in Kotlin:

  • Boolean
  • Byte
  • Char
  • Double
  • Float
  • Int
  • Long
  • Short

Boolean

In Kotlin, Boolean can hold either true or false. To declare a boolean variable, the var or val keyword can be used, followed by the variable name, and the assigned boolean value:

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

A boolean can be used to determine the outcome of if...else statements:

fun main(){
  val condition: Boolean = true


  if (condition) {
    // Code that gets executed if the variable is true
  } else {
    // Code that gets executed if the variable is false
  }
}

Byte

A Byte is a data type that is similar to an integer data type, but it is only 8 bits in size. While an integer can be a different size depending on the system, a byte can only hold values from -128 to 127.

Bytes are commonly used to store small pieces of data, such as characters in a text file or colors in an image.

Here is an example of how to declare a byte variable in Kotlin:

fun main() {
  val a: Byte = 50
  val b: Byte = 25
  val c: Byte = a + b as Byte


  print(c)
}

The output will be:

75

Calculations that exceed the byte range will produce unexpected results:

fun main() {
  val a: Byte = 120
  val b: Byte = 120
  val c: Byte = a + b as Byte


  print(c)
}

The expected output is 240, but since that exceeds the range for a byte, the output will be:

-88

Char

Char represents a primitive data type that can hold any character from the Unicode character set, which includes letters, digits, symbols, and special characters.

Here is an example of how to declare a character variable in Kotlin:

val ch: Char = 'A'

Double

Double represents a 64-bit floating-point number. It is a primitive data type that can hold values with a fractional component, such as 3.14 or 0.5.

Here is an example of how to declare a double variable in Kotlin:

fun main() {
  val a: Double = 3.14
  val b: Double = 2.71
  val c: Double = a * b as Double


  print(c)
}

The output of the above code will be:

8.5094

In this example, c will be assigned the value 8.5014, which is the result of 3.14 * 2.71.

A double can be used to perform more advanced operations, such as calculating the square root of a number or raising a number to the power of another number. For example:

import kotlin.math.sqrt
import kotlin.math.pow


fun main() {
  val a: Double = 16.0
  val b: Double = sqrt(a)
  val c: Double = a.pow(2)


  println("The square root of $a is $b.")
  println("$a raised to the power of 2 is $c.")
}

The output will be:

The square root of 16.0 is 4.0.
16.0 raised to the power of 2 is 256.0.

Float

Float represents a 32-bit floating-point number. It is a primitive data type that can hold values with a fractional component, such as 3.14 or 0.5.

Here is an example of how to declare a float in Kotlin:

fun main() {
  val a: Float = 3.14f
  val b: Float = 2.71f
  val c: Float = a * b as Float


  print(c)
}

The output will be:

8.5094

In this example, c will be assigned the value 8.5014, which is the result of 3.14 * 2.71.

Int

Int represents a 32-bit signed integer. It is a primitive data type that can hold values ranging from -2147483648 to 2147483647.

Here is an example of how to declare an integer variable in Kotlin:

fun main() {
  val a: Int = 50
  val b: Int = 25
  val c: Int = a + b


  print(c)
}

The output of the above code will be:

75

Long

Long represents a 64-bit signed integer. It is a primitive data type that can hold values ranging from -9223372036854775808 to 9223372036854775807.

Here is an example of how to declare a long variable in Kotlin:

fun main() {
  val a: Long = 500000000
  val b: Long = 250000000
  val c: Long = a + b


  print(c)
}

The output for the above code will be:

750000000

In this example, c will be assigned the value 750000000, which is the result of 500000000 + 250000000.

Short

Short represents a 16-bit signed integer. It is a primitive data type that can hold values ranging from -32768 to 32767.

Here is an example of how to declare a short variable in Kotlin:

fun main() {
  val a: Short = 50
  val b: Short = 25
  val c: Short = (a + b).toShort()


  print(c)
}

The output for the above code will be:

75

In this example, the c variable will be assigned the value 75, which is the result of 50 + 25. The toShort() function is used to convert the result to a Short type.

Non-Primitive Data Types

The following are non-primitive data types in Kotlin:

  • Any
  • Arrays
  • Class
  • Enum
  • List
  • Map
  • Nothing
  • Set
  • String
  • Unit

Arrays

An Array is a data structure that stores a fixed-size collection of elements of the same data type. They are non-primitive data types, which means they are derived from primitive data types or other non-primitive data types.

To declare an array in Kotlin, the arrayOf() function can be utilized, with the elements of the array specified within the parentheses. For instance:

fun main() {
  val numbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
}

In this example, the numbers variable is an array of integers that contains some numerical values. The type of the array is specified using the Array<Int> syntax, which indicates that the array contains elements of the Int type.

String

In Kotlin, a String is a data type that represents a sequence of characters. A string can be used to store and manipulate text in a program.

Here is an example of how to declare and initialize a string in Kotlin:

fun main() {
  val message: String = "Hello, World!"
  print(message)
}

The output for the above code will be:

Hello, World!

Strings are also immutable in Kotlin.

The + operator can be used to concatenate strings or the trim() function to remove leading and trailing whitespace from a string. For example:

fun main() {
  val greeting: String = "Hello, "
  val name: String = "John"
  val fullMessage: String = greeting + name
  println(fullMessage.trim())
}

The output for the above code will be:

Hello, John

Any

In Kotlin, the Any type is a supertype of all types in the language. It represents a general type that can hold any value.

Here is an example of how to declare a variable of type Any in Kotlin:

fun main() {
  val value: Any = 100
  val value2: Any = "Hello, World!"
  println(value)
  println(value2)
}

The output for the above code will be:

100
Hello, World!

Nothing

Nothing is a special type that represents the absence of a value. It is a subtype of all types in the language and cannot be instantiated.

The Nothing type is used to indicate that a function never returns a value. For example, a function that throws an exception or terminates the program will have a return type of Nothing.

Here is an example of a function that has a return type of Nothing:

fun error(): Nothing {
  throw IllegalStateException("An error occurred.")
}

In the above, the error() function throws an exception and does not return a value, therefore, its return type is Nothing.

Unit

In Kotlin, Unit is another special type that represents the absence of a value. It’s similar to Void in other programming languages and is used to indicate that a function does not return a value. Unit is also a subtype of Any which means that it can be used in place of any type.

The Unit type can be used to specify that a function has a return type of Unit when it is not possible to infer the return type from the function’s body. For example:

fun doSomething(): Unit {
  // Perform some action here
}

In the above example, the doSomething() function performs some action and does not return a value. Therefore, its return type is Unit.

Video Walkthrough

Watch this video to learn about various Kotlin data types, including variables, constants, strings, and arrays.

All contributors

Contribute to Docs

Learn Kotlin on Codecademy