In the realm of programming languages, arrays traditionally serve as containers for elements of the same data type. However, Kotlin, the versatile language developed by JetBrains, introduces a refreshing departure from this convention. In Kotlin, an array isn’t confined to homogenous data; instead, it becomes a dynamic repository capable of accommodating values of various data types within a single structure. This unique feature signifies that Kotlin arrays can seamlessly store integers, strings, characters, and more, all coexisting harmoniously within the same array. This flexibility not only sets Kotlin apart but also opens up a realm of possibilities for developers seeking a more expressive and adaptable approach to array management.

In this blog post, we will explore the intricacies of Kotlin arrays, unraveling the capabilities that make them a powerful tool in the hands of programmers.

Kotlin Array Properties

• Arrays are 0 index based
• The size of array is fixed, we can not increase or decrease once declare
• Arrays are mutable as array elements can be changed after declaration.

Kotlin array can be created using Array<T> class and using some Kotlin functions.

class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ...
}

1. Create an Array using the Array class

The Kotlin array can be created using the constructor of the Array class. The constructor expects two parameters: first is size of the array and second is an init function. The init function is used to initialize the array:

var numbers = Array(3, init = {
    i -> i * 3
})

Here, an array of size 3 is created and initialized by elements using the formula index * 3. The array created will contain [0, 3, 6].

2. Create an Array using functions

The easiest way to create an array is using arrayOf() function. We can pass the array elements as the parameter while calling the arrayOf() function.

Let us create an array of integers:

val marks = arrayOf(10,9,3,4,5)

In the above code, we created an array of integers. As the size of an array is fixed, we cannot add elements to this later on. The size of this array will be fixed i.e. 5.

In the above example, the type of array is not mentioned. Hence, different types of elements can be added to this array:

val differentTypeArray = arrayOf(10,4,5,"Array string", 'c', 10.5f)

If we want to fix the type of the elements in an array, the type can be mentioned at the time of the creation of the array, like this:

val marks = arrayOf<Int>(10,4,5,8,9)

3. Primitive types Array

Kotlin also has classes that represent arrays of primitive types and their respective helper functions likeByteArray -> byteArrayOf(), ShortArray ->shortArrayOf(), IntArray -> intArrayOf(), and so on. using both we can create arrays in kotlin

val x: IntArray = intArrayOf(0, 1, 2)

// or

// Example of initializing the values in the array using a lambda
// Array of int of size 5 with values [0, 1, 2] (values initialized to their index value)
var arr = IntArray(3) { it * 1 }

Note →

The elements of an array can be accessed and modified using get() and set() functions. instead of this, we can also use [] to access array elements providing the index value within the square brackets.

fun main() {
    val marks = arrayOf<Int>(10,4,5,8,9)
    println(marks.get(0))
    // update the value of the first element of the array
    marks.set(0,100)
    println(marks.get(0))

    println(marks[1])
    // setting new value for second element of array
    marks[1] = 200
    println(marks[1])
}

Traversing the Array using for loop and forEach()

fun main() {
    val marks = arrayOf<Int>(10,4,5,8,9)

    // traverse the array using for loop and print 
   for (i in marks)
        println(i)


   // Array elements can also be accessed using forEach() in Kotlin

    marks.forEach { i ->
        println(i)
    }
}

Conclusion

Kotlin arrays offer a robust and flexible mechanism for working with collections of data. Whether you’re developing Android applications or backend services, understanding the intricacies of Kotlin arrays is essential for writing efficient and concise code. This guide has covered the basics, manipulation, and various array functions, empowering you to harness the full potential of Kotlin arrays in your projects.

Happy Coding : )