How to Initialize Arrays in Kotlin with Values

By the end of this page, you will understand how to create arrays in Kotlin using predefined values, when to use arrayOf(...), when to use primitive array types like intArrayOf(...), and how Kotlin array syntax differs from Java.

Kotlin supports arrays, but its syntax is different from Java.

In Java, array creation often uses a type followed by square brackets and a new expression. Kotlin does not use new, and array creation is usually done through functions such as arrayOf(...).

For example:

val numbers = arrayOf(10, 20, 30, 40, 50)

This creates an Array<Int>.

However, Kotlin also has primitive array types for better performance:

• IntArray
• DoubleArray
• BooleanArray
• CharArray
• LongArray
• FloatArray
• ShortArray
• ByteArray

So if you specifically want an array of primitive Int values, Kotlin commonly uses:

val numbers = intArrayOf(10, , , , )

Think of a Kotlin array as a row of numbered boxes.

• Each box has a position: 0, 1, 2, and so on.
• You can fill the boxes with values when you create the array.
• arrayOf(...) is like saying: "Create a row of boxes and put these items in them."
• intArrayOf(...) is like saying: "Create a row of integer boxes specifically for Int values."

So instead of Java's new int[] {...}, Kotlin says: "Use this array-building function and provide the values."

Basic array initialization

val numbers = arrayOf(10, 20, 30, 40, 50)

This creates an Array<Int>.

Primitive integer array

val numbers = intArrayOf(10, 20, 30, 40, 50)

This creates an IntArray.

String array

val names = arrayOf("Alice", "Bob", "Charlie")

This creates an Array<String>.

Accessing values

val numbers = intArrayOf(10, 20, 30)
println(numbers[0]) // 10
println(numbers[1]) 

Consider this example:

val numbers = intArrayOf(10, 20, 30)
println(numbers[0])
println(numbers[2])

Step by step:

1. intArrayOf(10, 20, 30) creates an array containing three integers.
2. The array is stored in the variable numbers.
3. numbers[0] reads the first element, which is 10.
4. println(numbers[0]) prints 10.
5. numbers[2] reads the third element, which is 30.
6. println(numbers[2]) prints 30.

Output:

10
30

Here is another traceable example:

val values = Array(4) { index -> index + 1 }
println(values.joinToString())

Arrays in Kotlin are useful when you need fixed-size indexed data.

Common examples

• Storing numeric data such as scores, coordinates, or sensor readings
• Working with Java APIs that expect arrays
• Processing command-line arguments or fixed sets of values
• Image or audio data where indexed access matters
• Performance-sensitive code using primitive arrays like IntArray

Example: fixed monthly sales values

val sales = intArrayOf(120, 150, 90, 200)
println(sales[3]) // 200

Example: passing arrays to functions

fun printNames(names: Array<String>) {
    for (name in names) {
        println(name)
    }
}

val team = arrayOf("Ana", "Ben", "Chris")
printNames(team)

Example: generated values

val evenNumbers = IntArray() { it *  }
println(evenNumbers.joinToString()) 

In real Kotlin codebases, arrays are used less often than lists, but they are still important.

Common patterns

Interoperating with Java

Many Java libraries use arrays in method parameters or return types.

val args = arrayOf("--debug", "--port=8080")

Using primitive arrays for performance

If a program handles many numeric values, developers often prefer primitive arrays.

val temperatures = DoubleArray(7)

Initializing from known constants

Configuration-like values may be stored in arrays when the size is fixed.

val supportedCodes = arrayOf("en", "es", "fr")

Transforming data for APIs

Developers may build arrays from collections before calling functions that require arrays.

val namesList = listOf("Alice", "Bob")
val namesArray = namesList.toTypedArray()

Guarding against invalid access

Because arrays are index-based, developers often validate indices before use.

1. Expecting Java syntax to work in Kotlin

Broken code:

val numbers = new int[] {10, 20, 30}

Why it fails:

• Kotlin does not use new.
• Kotlin does not use Java's array literal syntax.

Correct version:

val numbers = intArrayOf(10, 20, 30)

2. Confusing Array<Int> with IntArray

val a = arrayOf(1, 2, 3)   // Array<Int>
val b = intArrayOf(1, 2, 3) // IntArray

These are not the same type.

Avoid this mistake by checking what a function expects.

3. Using the wrong constructor style

Broken idea:

Arrays in Kotlin compared

Quick syntax

val a = arrayOf(1, 2, 3)          // Array<Int>
val b = intArrayOf(1, 2, 3)       // IntArray
val c = arrayOf("a", "b")       // Array<String>
val d = Array(3) { it * 10 }      // Array<Int>: [0, 10, 20]
val e = IntArray(3) { it + 1 }    // IntArray: [1, 2, 3]

Rules to remember

• Kotlin does not use new for arrays.
• arrayOf(...) creates a generic object array.
• intArrayOf(...) creates a primitive integer array.
• Arrays have fixed size.
• Indexing starts at 0.
• Use array[index] to read or update values.

Useful helpers

println(arr.size)
println(arr.indices)
println(arr.joinToString())

How do you initialize an array in Kotlin with values?

Use arrayOf(...) for general arrays or intArrayOf(...) for primitive integers.

val numbers = intArrayOf(10, 20, 30)

What is the Kotlin equivalent of new int[] { ... } in Java?

The closest Kotlin equivalent is:

val numbers = intArrayOf(10, 20, 30)

Should I use arrayOf or intArrayOf in Kotlin?

Use arrayOf(...) for generic object arrays. Use intArrayOf(...) when you need an IntArray with primitive integers.

Are Kotlin arrays fixed size?

Yes. Once created, an array's size cannot change.

What is the difference between Array<Int> and List<Int> in Kotlin?

• List — often used instead of arrays in Kotlin for everyday collection handling.
• MutableList — useful when you need a resizable collection.
• IntArray — the primitive integer array type closely related to this topic.
• Array — the generic Kotlin array type.
• Collections in Kotlin — helps explain when to choose arrays versus lists or sets.
• Indexing — important because arrays are accessed by numeric position.
• Loops in Kotlin — commonly used to iterate through array elements.
• Nullability in Kotlin — relevant when working with arrays that may contain null values.