Create Arrays by Size in Kotlin: IntArray and Array

Kotlin provides specialized primitive arrays such as IntArray and generic object arrays such as Array<T>. For the direct equivalent of Java's new int[n], use IntArray(n). You will also learn how to create arrays with custom initial values and when to use each array type.

Kotlin has two main array categories:

• Primitive arrays, such as IntArray, DoubleArray, and BooleanArray, store primitive values efficiently.
• Generic arrays, written as Array<T>, store objects or nullable values.

For Java code like this:

int[] a = new int[n];

use this Kotlin code:

val a = IntArray(n)

IntArray(n) creates an array containing n integers. Every element starts as 0, matching Java's behavior for an int[].

This distinction matters because IntArray is not the same type as Array<Int>. IntArray is intended for numeric data and avoids boxing each integer into an Integer object on the JVM. In most cases, prefer IntArray when you need an array of Int values.

Think of an array as a row of numbered storage boxes.

When you write:

val scores = IntArray(5)

Kotlin creates five boxes numbered from 0 to 4:

index:   0   1   2   3   4
value:   0   0   0   0   0

IntArray(5) tells Kotlin how many boxes to create. Since you did not provide values, each integer box receives its default value: 0.

When you provide an initializer, you are giving Kotlin a rule for filling every box.

Create an integer array by size:

val n = 5
val numbers = IntArray(n)

println(numbers.contentToString())
// [0, 0, 0, 0, 0]

Access or change values using zero-based indexes:

val numbers = IntArray(3)

numbers[0] = 10
numbers[1] = 20
numbers[2] = 30

println(numbers[1]) // 20

Create an IntArray with a calculated initial value for each index:

val squares = IntArray(5) { index -> index * index }

println(squares.contentToString())
// [0, 1, 4, 9, 16]

Create a generic Array<Int> instead:

val values = Array(5) { 0 }

println(values.contentToString())
// [0, 0, 0, 0, 0]

Although this looks similar, Array<Int> stores boxed Int objects on the JVM. Use it only when an API specifically requires Array<Int> or when you need nullable integers:

val answers: Array<Int?> = arrayOfNulls(3)
println(answers.contentToString())
// [null, null, null]

Consider this code:

val size = 4
val temperatures = IntArray(size) { index -> index + 18 }

temperatures[2] = 25

println(temperatures.contentToString())

Execution trace:

1. size is assigned the value 4.
2. IntArray(size) creates four positions: indexes 0, 1, 2, and 3.
3. The initializer runs once per index:
   • Index 0: 0 + 18 produces 18.
   • Index 1: 1 + 18 produces 19.
   • Index 2: 2 + 18 produces 20.
   • Index 3: 3 + 18 produces 21.
4. The array is now [18, 19, 20, 21].
5. temperatures[2] = 25 replaces the value at index 2.
6. The output is:

[18, 19, 25, 21]

Arrays created by size are useful when the number of positions is known before the values are processed.

• Daily counters: Store one count for each hour of the day with IntArray(24).
• Game boards: Store a fixed grid of cells, such as a 3×3 tic-tac-toe board.
• Image or audio processing: Keep fixed-size pixel, sample, or color-channel data.
• Frequency counting: Create an array with one slot per possible category, such as digits 0 through 9.
• Algorithm problems: Store dynamic-programming results or visited states when the maximum size is known.

Example: count occurrences of each digit in a string.

val counts = IntArray(10)
val input = "102301"

for (character in input) {
    val digit = character.digitToInt()
    counts[digit]++
}

println(counts.contentToString())
// [2, 2, 1, 1, 0, 0, 0, 0, 0, 0]

In production Kotlin code, developers choose the array type based on the data and API requirements.

Use primitive arrays for numeric storage

fun calculateTotal(prices: IntArray): Int {
    var total = 0
    for (price in prices) {
        total += price
    }
    return total
}

This is a suitable use of IntArray because prices are non-null integers.

Validate a requested size first

Avoid creating arrays from invalid input:

fun createScores(size: Int): IntArray {
    require(size >= 0) { "Size must not be negative" }
    return IntArray(size)
}

require provides a clear error message rather than letting an invalid size reach later logic.

Use an initializer to avoid a separate filling loop

val ids = IntArray(100) { index -> index + 1 }

This is concise and makes the initialization rule clear.

Use lists when the size must grow or shrink

val activeUserIds = mutableListOf<Int>()
activeUserIds.add(42)

Arrays have a fixed length. A MutableList is often more appropriate for data collected over time.

Using Array<Int>(n) without an initializer

This does not compile:

// Broken: Array requires an initializer function.
val values = Array<Int>(5)

Use an initializer:

val values = Array(5) { 0 }

Or, for integer data, prefer:

val values = IntArray(5)

Expecting IntArray and Array<Int> to be interchangeable

They are different types:

val primitiveNumbers = IntArray(3)
val objectNumbers = Array(3) { 0 }

A function accepting IntArray cannot directly receive Array<Int>. Match the parameter type required by the function or API.

Accessing an index outside the array

val values = IntArray(3)
values[3] = 10 // Broken: valid indexes are 0, 1, and 2.

For an array of size n, valid indexes range from 0 through n - 1.

Assuming arrays can grow

val values = IntArray(2)
// values.add(10) // Broken: arrays do not have add.

Use MutableList<Int> when you need to add or remove items dynamically.

Printing an array directly

val values = IntArray(3)
println(values)

This may print an implementation-style representation rather than the contents. Use:

println(values.contentToString())

IntArray compared with Array<Int>:

// Java: int[] a = new int[n]
val a = IntArray(n)              // n zeros

// Set every value to the same number
val tens = IntArray(n) { 10 }

// Use the index while filling the array
val indexes = IntArray(n) { it }

// Generic object array
val names = Array(n) { "Unknown" }

// Nullable object array, filled with null
val optionalNames = arrayOfNulls<String>(n)

// Read and write
val first = a[0]
a[0] = 42

// Length
println(a.size)

// Display contents
println(a.contentToString())

Rules to remember:

• IntArray(size) is the closest Kotlin equivalent to Java new int[size].
• Array indexes start at 0.
• Array size is fixed after creation.
• Use Array(size) { value } for object arrays or custom initialization.
• Use MutableList when the collection must change size.

What is the Kotlin equivalent of new int[n] in Java?

Use IntArray(n). It creates n integer elements initialized to 0.

Does IntArray(n) create null values?

No. IntArray holds non-null Int values, and new elements start at 0.

How do I create an array filled with the same value in Kotlin?

Use an initializer:

val values = IntArray(5) { 7 }

This produces [7, 7, 7, 7, 7].

How do I create a Kotlin string array with a given size?

Provide an initializer value:

val names = Array(3) { "" }

For null entries, use arrayOfNulls<String>(3).

Why does Array<Int>(n) not work?

Array requires a function that supplies a value for every index. Write Array(n) { 0 }, or use IntArray(n) for integer values.

Can an IntArray be resized?

No. Its size is fixed. Create a new array, use copyOf, or choose a MutableList<Int> if resizing is required.

How can I print a Kotlin array's values?

Use contentToString():

println(values.contentToString())

• Kotlin collections — Learn when List and MutableList are more suitable than fixed-size arrays.
• Primitive types in Kotlin — Explains Int, Double, Boolean, and their specialized array types.
• Array indexing — Covers zero-based indexes and avoiding IndexOutOfBoundsException.
• Loops in Kotlin — Useful for reading, updating, and processing every array element.
• Lambda expressions — Array initializer functions such as IntArray(n) { it * 2 } use lambdas.
• Null safety — Helps explain why Array<Int?> can contain null while IntArray cannot.
• Kotlin require validation — Useful for checking array sizes and other function inputs before processing.