Kotlin Array

Array is one of the most fundamental data structure in practically all programming languages. The idea behind an array is to store multiple items of the same data-type,such as an integer or string under a single variable name.
Arrays are used to organize data in programming so that a related set of values can be easily sorted or searched.
Here are some basic properties of arrays –

  • They are stored in contiguous memory locations.
  • They can be accessed programmatically through their indexes (array[1], array[0], etc.)
  • They are mutable.
  • Their size is fixed.

To learn more about the array data structure, check out Array tutorials.

Creating an array –

In Kotlin, arrays are not a native data type, but a mutable collection of similar items which are represented by the Array class.
There are two ways to define an array in Kotlin.

Using the arrayOf() function –

We can use the library function arrayOf() to create an array by passing the values of the elements to the function.
Syntax:

val num = arrayOf(1, 2, 3, 4)   //implicit type declaration
val num = arrayOf<Int>(1, 2, 3) //explicit type declaration

Kotlin program of creating array using arrayOf() and arrayOf<Int> functions-

filter_none

edit
close

play_arrow

link
brightness_4
code

fun main()
{
    // declaring an array using arrayOf()
    val arrayname = arrayOf(1, 2, 3, 4, 5)
    for (i in 0..arrayname.size-1)
    {
        print(" "+arrayname[i])
    }
    println()
    // declaring an array using arrayOf<Int>
    val arrayname2 = arrayOf<Int>(10, 20, 30, 40, 50)
    for (i in 0..arrayname2.size-1)
    {
        print(" "+arrayname2[i])
    }
}

chevron_right


Output:

 1 2 3 4 5
 10 20 30 40 50

Using the Array constructor –

Since Array is a class in Kotlin, we can also use the Array constructor to create an array.
The constructor takes two parameters:

  1. The size of the array, and
  2. A function which accepts the index of a given element and returns the initial value of that element.

Syntax:

 val num = Array(3, {i-> i*1})

In the above example, we pass the size of the array as 3 and a lambda expression which initializes the element values from 0 to 9.

Kotlin program of creating array using constructor –

filter_none

edit
close

play_arrow

link
brightness_4
code

fun main()
{
    val arrayname = Array(5, { i -> i * 1 })
    for (i in 0..arrayname.size-1)
    {
        println(arrayname[i])
    }
}

chevron_right


Output:

0
1
2
3
4

Apart from these, Kotlin also has some built-in factory methods to create arrays of primitive data types, such as byteArray, intArray, shortArray, etc. These classes do not extend the Array class; however, they implement the same methods and properties.

For example, the factory method to create an integer array is:

val num = intArrayOf(1, 2, 3, 4)

Other factory methods available for creating arrays:

  • byteArrayOf()
  • charArrayOf()
  • shortArrayOf()
  • longArrayOf()

Accessing and modifying arrays –

So far, we have seen how to create and initialize an array in Kotlin. Now, let’s see how to access and modify them.
Again, there are two ways of doing this:

    Using get() and set() methods –

    As you know, an array in Kotlin is basically a class. Therefore, we can access the data of a class object via its member functions. The get() and set() functions are said to be member functions.

    The get() method takes a single parameter—the index of the element and returns the value of the item at that index.
    Syntax:

    val x = num.get(0)
    

    The set() method takes 2 parameters: the index of the element and the value to be inserted.
    Syntax:

    num.set(1, 3)
    

    The above code sets the value of the second element in the array to 3

    Using the index operator [ ] –

    The [ ] operator can be used to access and modify arrays.
    To access an array element, the syntax would be:

    val x = num[1]
    

    This will assign the value of the second element in num to x.

    To modify an array element, we should do:

    num[2] = 5;
    

    This will change the value of the third element in the num array to 5.

    Note: Internally, the index operator or [ ] is actually an overloaded operator (see operator overloading) and only stands for calls to the get() and set() member functions.

    Here is a working example of Kotlin array manipulation in which we create an array, modify its values, and access a particular element:

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    fun main()
    {   // declare an array using arrayOf()
        val num = arrayOf(1, 2, 3, 4, 5)
      
        num.set(0, 10// set the first element equal to 10
        num.set(1, 6)   // set the secondelement equal to 6
      
        println(num.get(0)) // print the first element using get()
        println(num[1]) // print the second element using []
    }

    chevron_right

    
    

    Output:

    10
    6
    

    Traversing Arrays –

    One important property of an array is that it can be traversed programmatically, and each element in the array can be manipulated individually. Kotlin supports few powerful ways to traverse array.

    The simplest and most commonly used idiom when it comes to traversing an array is to use the for-loop.
    Syntax:

    for(i in num.indices){
          println(num[i])
      }
    

    Kotlin program of array traversal using for loop-

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Traversing an array
    fun main()
    {
        val num = arrayOf<Int>(1, 2, 3, 4, 5)
        num.set(0, 10)
        num.set(1, 6)
        for (i in num.indices)
        {
            println(num[i])
        }
    }

    chevron_right

    
    

    Output:

    10
    6
    3
    4
    5
    

    Alternatively, we can use the range to achieve the same effect. In Kotlin, a range is an interval between two values (start and end) and can be created using the (..) operator. Traversal through the range can be then done using the in keyword.
    Syntax for range:

    for (i in 0..10){
        println(i)
    }
    

    The range of elements in an array is defined from 0 to size-1. So, to traverse an array using range, we run a loop from 0 to size-1 on the array name.
    Kotlin program of array traversal using range-

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Traversing an array
    fun main()
    {
        val arrayname = arrayOf<Int>(1, 2, 3, 4, 5)
        for (i in 0..arrayname.size-1)
        {
            println(arrayname[i])
        }
    }

    chevron_right

    
    

    Output:

    1
    2
    3
    4
    5
    

    Another arguably less tedious, way to do the above is using the foreach loop.

    Syntax:

    arrayname.forEach({index->println(index)})
    

    Kotlin program of array traversal using foreach loop-

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // Traversing an array
    fun main()
    {
        val arrayname = arrayOf<Int>(1, 2, 3, 4, 5)
        arrayname.forEach({ index -> println(index) })
    }

    chevron_right

    
    

    Output:

    1
    2
    3
    4
    5
    


    My Personal Notes arrow_drop_up

    I am a software engineer with a background in backend technologies, RESTful APIs, and microservices In my free time, I write tutorials and technical articles for various websites

    If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

    Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




    Article Tags :

    Be the First to upvote.


    Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.