Kotlin Array last Function

The last function in Kotlin is used to return the last element of an array that matches a given predicate. If no predicate is provided, it returns the last element of the array. This function is part of the Kotlin standard library and provides a simple way to access elements from the end of an array.

Table of Contents

1. Introduction
2. last Function Syntax
3. Understanding last
4. Examples
   • Basic Usage
   • Using last with a Condition
   • Handling Empty Arrays
   • Using last with Custom Types
5. Real-World Use Case
6. Conclusion

Introduction

The last function is used to return the last element of an array, either unconditionally or based on a given condition. If no such element is found when a condition is provided or if the array is empty when no condition is provided, it throws an exception.

last Function Syntax

The syntax for the last function is as follows:

fun <T> Array<out T>.last(): T
fun <T> Array<out T>.last(predicate: (T) -> Boolean): T

Parameters:

• predicate: A lambda function that takes an element of type T and returns true if the element matches the condition, false otherwise (optional).

Returns:

• The last element of the array or the last element that matches the predicate.

Throws:

• NoSuchElementException if no element is found that matches the predicate, or if the array is empty when no predicate is provided.

Understanding last

The last function provides a convenient way to access elements from the end of an array. When used without a predicate, it returns the very last element. When used with a predicate, it returns the last element that matches the given condition.

Examples

Basic Usage

To demonstrate the basic usage of last, we will create an array of integers and return the last element.

Example

fun main() {
    val numbers = arrayOf(1, 2, 3, 4, 5)
    val lastNumber = numbers.last()
    println("Last element: $lastNumber")
}

Output:

Last element: 5

Using last with a Condition

This example shows how to use last to return the last element that matches a given condition.

Example

fun main() {
    val numbers = arrayOf(1, 2, 3, 4, 5)
    val lastEvenNumber = numbers.last { it % 2 == 0 }
    println("Last even element: $lastEvenNumber")
}

Output:

Last even element: 4

Handling Empty Arrays

This example demonstrates how to handle cases where the array is empty.

Example

fun main() {
    val emptyArray = emptyArray<Int>()
    try {
        val lastElement = emptyArray.last()
        println("Last element: $lastElement")
    } catch (e: NoSuchElementException) {
        println("Error: ${e.message}")
    }
}

Output:

Error: Array is empty.

Using last with Custom Types

This example shows how to use last with an array of custom objects.

Example

data class Person(val name: String, val age: Int)

fun main() {
    val people = arrayOf(
        Person("Ravi", 25),
        Person("Anjali", 30),
        Person("Priya", 22)
    )

    val lastPersonAbove25 = people.last { it.age > 25 }
    println("Last person above 25: $lastPersonAbove25")
}

Output:

Last person above 25: Person(name='Anjali', age=30)

Real-World Use Case

Finding the Last Active User

In real-world applications, the last function can be used to find the last element that matches a specific condition, such as finding the last active user in a list.

Example

data class User(val name: String, val isActive: Boolean)

fun main() {
    val users = arrayOf(
        User("Ravi", false),
        User("Anjali", true),
        User("Priya", true)
    )

    val lastActiveUser = users.last { it.isActive }
    println("Last active user: $lastActiveUser")
}

Output:

Last active user: User(name='Priya', isActive=true)

Conclusion

The last function in Kotlin is a convenient method for accessing the last element of an array, either unconditionally or based on a given predicate. It provides a simple way to retrieve elements from the end of an array and can be useful for filtering and finding elements based on specific conditions. By understanding and using this function, you can effectively manage element access operations in your Kotlin applications.