Kotlin Array

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 –

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:








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 [] }

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-








// 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])     } }

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-








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

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-








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

Output:

1
2
3
4
5





Like Article
Suggest improvement
Previous
Kotlin labelled continue
Next
Kotlin String
Share your thoughts in the comments
Add Your Comment
Please Login to comment...