Kotlin Array Class

Introduction

In Kotlin, an Array is a collection of elements of a specific type. It is a fixed-size collection, which means once you create an array, you cannot change its size. Arrays are widely used for storing and managing data in Kotlin.

What is Array?
Creating Arrays
Accessing and Modifying Array Elements
Common Array Functions
Examples of Array
Real-World Use Case
Conclusion

1. What is Array?

Array in Kotlin is a class that represents an array of elements. The elements can be of any type, and the array has a fixed size. It provides various functions to interact with the elements.

2. Creating Arrays

You can create an array in Kotlin using the arrayOf function or the Array constructor.

Syntax

val array1 = arrayOf(1, 2, 3, 4, 5)
val array2 = Array(5) { it * 2 }

3. Accessing and Modifying Array Elements

You can access and modify array elements using the index.

Example

val array = arrayOf("apple", "banana", "cherry")

// Accessing elements
val firstElement = array[0]

// Modifying elements
array[1] = "blueberry"

4. Common Array Functions

Kotlin arrays come with several useful functions:

size: Returns the number of elements in the array.

val array = arrayOf(1, 2, 3)
println(array.size) // Output: 3

get(index: Int): Returns the element at the specified index.

val array = arrayOf(1, 2, 3)
val element = array.get(1) // element is 2

set(index: Int, value: T): Sets the element at the specified index to the given value.
```
val array = arrayOf(1, 2, 3)
array.set(1, 5) // array is now [1, 5, 3]
```

first(): Returns the first element of the array.

val array = arrayOf(1, 2, 3)
val firstElement = array.first() // firstElement is 1

last(): Returns the last element of the array.

val array = arrayOf(1, 2, 3)
val lastElement = array.last() // lastElement is 3

indexOf(element: T): Returns the index of the first occurrence of the specified element, or -1 if the element is not found.
```
val array = arrayOf(1, 2, 3)
val index = array.indexOf(2) // index is 1
```

contains(element: T): Returns true if the array contains the specified element.

val array = arrayOf(1, 2, 3)
val contains = array.contains(2) // contains is true

reverse(): Reverses the array in place.

val array = arrayOf(1, 2, 3)
array.reverse() // array is now [3, 2, 1]

sort(): Sorts the array in ascending order.

val array = arrayOf(3, 1, 2)
array.sort() // array is now [1, 2, 3]

forEach(action: (T) -> Unit): Performs the given action on each element.

val array = arrayOf(1, 2, 3)
array.forEach { println(it) } // prints 1, 2, 3

map(transform: (T) -> R): Returns a list containing the results of applying the given transform function to each element in the original array.
```
val array = arrayOf(1, 2, 3)
val newList = array.map { it * 2 } // newList is [2, 4, 6]
```

5. Examples of Array

Example 1: Using `forEach`

fun main() {
    val array = arrayOf("apple", "banana", "cherry")

    array.forEach { element ->
        println(element)
    }
}

Output:

apple
banana
cherry

Example 2: Using `map`

fun main() {
    val array = arrayOf(1, 2, 3)
    val doubledArray = array.map { it * 2 }

    println(doubledArray) // Output: [2, 4, 6]
}

Example 3: Using `reverse`

fun main() {
    val array = arrayOf(1, 2, 3)
    array.reverse()

    println(array.joinToString()) // Output: 3, 2, 1
}

Example 4: Finding the Index of an Element

fun main() {
    val array = arrayOf(1, 2, 3)
    val index = array.indexOf(2)

    println(index) // Output: 1
}

Example 5: Checking if an Array Contains an Element

fun main() {
    val array = arrayOf(1, 2, 3)
    val contains = array.contains(2)

    println(contains) // Output: true
}

Example 6: Getting the First and Last Elements

fun main() {
    val array = arrayOf(1, 2, 3)
    val firstElement = array.first()
    val lastElement = array.last()

    println("First: $firstElement, Last: $lastElement") // Output: First: 1, Last: 3
}

Example 7: Setting an Element's Value

fun main() {
    val array = arrayOf(1, 2, 3)
    array.set(1, 5)

    println(array.joinToString()) // Output: 1, 5, 3
}

Example 8: Using `for` Loop to Traverse an Array

fun main() {
    val array = arrayOf("apple", "banana", "cherry")

    for (element in array) {
        println(element)
    }
}

Output:

apple
banana
cherry

Example 9: Sorting an Array

fun main() {
    val array = arrayOf(3, 1, 2)
    array.sort()

    println(array.joinToString()) // Output: 1, 2, 3
}

Example 10: Calculating Sum of Elements

fun main() {
    val array = arrayOf(1, 2, 3)
    val sum = array.sum()

    println(sum) // Output: 6
}

Example 11: Filtering an Array

fun main() {
    val array = arrayOf(1, 2, 3, 4, 5)
    val evenNumbers = array.filter { it % 2 == 0 }

    println(evenNumbers) // Output: [2, 4]
}

6. Real-World Use Case: Processing Data

Arrays can be used to store and process data in various applications. For example, in a simple data processing application, you might use arrays to store and manipulate datasets.

Example: Temperature Data Processing

fun main() {
    val temperatures = arrayOf(30, 32, 29, 35, 31)

    // Calculate the average temperature
    val average = temperatures.sum() / temperatures.size
    println("Average temperature: $average")

    // Find the highest temperature
    val highest = temperatures.maxOrNull()
    println("Highest temperature: $highest")
}

Output:

Average temperature: 31
Highest temperature: 35

Conclusion

Kotlin arrays are a fundamental part of the language, providing a way to store and manipulate collections of elements. With various useful functions, arrays can be efficiently used in different applications, from simple data storage to complex data processing tasks. Understanding these functions and their usage is essential for effective Kotlin programming.

Java Guides

Search This Blog