How to access elements in an array in Kotlin

How to access elements in an array in Kotlin.

Here's a step-by-step tutorial on how to access elements in an array in Kotlin.

Declare an Array:
- To begin, declare an array in Kotlin using the arrayOf function. For example, to create an array of integers, you can use the following code:
```
val numbers = arrayOf(1, 2, 3, 4, 5)
```
Access Elements by Index:
- In Kotlin, you can access elements in an array by their index. Array indices start from 0, so the first element is at index 0, the second element is at index 1, and so on.
- To access a specific element, use the square bracket notation and provide the index of the element inside the brackets. For example, to access the second element in the numbers array, use the following code:
```
val secondNumber = numbers[1]
```
Iterate Over Array Elements:
- If you want to access all elements in an array, you can use a loop to iterate over each element. There are multiple ways to iterate over an array in Kotlin.
- Using a traditional for loop:
```
for (i in numbers.indices) {
    val number = numbers[i]
    // Do something with the number
}
```
- Using a forEach loop:
```
numbers.forEach { number ->
    // Do something with the number
}
```
- Using a forEachIndexed loop (to access both index and element):
```
numbers.forEachIndexed { index, number ->
    // Do something with the index and number
}
```
Check Array Bounds:
- It's essential to ensure that the index you're using to access an element is within the array's bounds. Trying to access an element outside the valid index range will result in an ArrayIndexOutOfBoundsException.
- To avoid this exception, you can check the array's size using the size property before accessing any element. For example:
```
if (index >= 0 && index < numbers.size) {
    val element = numbers[index]
    // Do something with the element
} else {
    // Handle out-of-bounds index
}
```
Nullability and Safe Access:
- In Kotlin, arrays can contain nullable elements. To access elements in a nullable-safe manner, you can use the safe access operator (?).
- When using the safe access operator, if the element at the given index is null, the result will be null. Otherwise, it will return the element's value.
- Here's an example:
```
val nullableNumbers = arrayOf(1, 2, null, 4, 5)
val thirdNumber = nullableNumbers.getOrNull(2)
```
- In this case, thirdNumber will be null because the element at index 2 is null.

That's it! You now know how to access elements in an array in Kotlin. You can use index-based access, iterate over the array, check array bounds, and handle nullable elements using the safe access operator.