Kotlin IndexOutOfBoundsException

Introduction

In Kotlin, IndexOutOfBoundsException is a runtime exception that is thrown to indicate that an index of some sort (such as to an array, to a string, or to a list) is out of the valid range. This exception is part of the Kotlin (and Java) standard library and typically occurs when you try to access an element at an invalid index.

Table of Contents

1. What is IndexOutOfBoundsException?
2. Common Causes of IndexOutOfBoundsException
3. Handling IndexOutOfBoundsException
4. Examples of IndexOutOfBoundsException
5. Real-World Use Case
6. Conclusion

1. What is IndexOutOfBoundsException?

IndexOutOfBoundsException is a subclass of RuntimeException and is used to indicate that an index is out of range. This can happen when accessing arrays, lists, or strings with an invalid index.

Syntax

throw IndexOutOfBoundsException("Exception message")

2. Common Causes of IndexOutOfBoundsException

• Accessing an element at a negative index.
• Accessing an element at an index greater than or equal to the size of the array, list, or string.
• Using a loop with incorrect index boundaries.

Example

fun main() {
    val list = listOf(1, 2, 3)
    val element = list[3] // This will cause IndexOutOfBoundsException
}

3. Handling IndexOutOfBoundsException

You can handle IndexOutOfBoundsException using a try-catch block to prevent your program from crashing.

Example

fun main() {
    val list = listOf(1, 2, 3)
    try {
        val element = list[3]
    } catch (e: IndexOutOfBoundsException) {
        println("Caught an index out of bounds exception: ${e.message}")
    }
}

4. Examples of IndexOutOfBoundsException

Example 1: Accessing Invalid Index in a List

This example demonstrates handling an invalid index access in a list.

fun main() {
    val list = listOf(1, 2, 3)
    try {
        val element = list[3]
    } catch (e: IndexOutOfBoundsException) {
        println("Caught an index out of bounds exception: ${e.message}")
    }
}

Output:

Caught an index out of bounds exception: Index 3 out of bounds for length 3

Explanation:
This example catches and handles an IndexOutOfBoundsException caused by accessing an invalid index in a list.

Example 2: Accessing Invalid Index in an Array

This example demonstrates handling an invalid index access in an array.

fun main() {
    val array = arrayOf(1, 2, 3)
    try {
        val element = array[3]
    } catch (e: IndexOutOfBoundsException) {
        println("Caught an index out of bounds exception: ${e.message}")
    }
}

Output:

Caught an index out of bounds exception: Index 3 out of bounds for length 3

Explanation:
This example catches and handles an IndexOutOfBoundsException caused by accessing an invalid index in an array.

Example 3: Accessing Invalid Index in a String

This example demonstrates handling an invalid index access in a string.

fun main() {
    val str = "Kotlin"
    try {
        val char = str[6]
    } catch (e: IndexOutOfBoundsException) {
        println("Caught an index out of bounds exception: ${e.message}")
    }
}

Output:

Caught an index out of bounds exception: Index 6 out of bounds for length 6

Explanation:
This example catches and handles an IndexOutOfBoundsException caused by accessing an invalid index in a string.

Example 4: Loop with Incorrect Index Boundaries

This example demonstrates handling an invalid index access caused by a loop with incorrect index boundaries.

fun main() {
    val list = listOf(1, 2, 3)
    try {
        for (i in 0..list.size) {
            println(list[i])
        }
    } catch (e: IndexOutOfBoundsException) {
        println("Caught an index out of bounds exception: ${e.message}")
    }
}

Output:

1
2
3
Caught an index out of bounds exception: Index 3 out of bounds for length 3

Explanation:
This example catches and handles an IndexOutOfBoundsException caused by a loop that iterates beyond the valid index range of the list.

5. Real-World Use Case: Safe Access to List Elements

In a real-world scenario, you might need to safely access elements in a list, providing a default value if the index is invalid.

Example: Safe Access to List Elements

fun getElementAtIndex(list: List<Int>, index: Int): Int {
    return if (index in 0 until list.size) {
        list[index]
    } else {
        -1 // Default value
    }
}

fun main() {
    val list = listOf(1, 2, 3)
    println(getElementAtIndex(list, 2)) // Output: 3
    println(getElementAtIndex(list, 3)) // Output: -1
}

Explanation:
This example shows how to safely access elements in a list by checking if the index is within the valid range and providing a default value if it is not.

Conclusion

IndexOutOfBoundsException in Kotlin is a runtime exception that occurs when an index is out of range. By understanding how to handle IndexOutOfBoundsException using try-catch blocks and validating index boundaries before accessing elements, you can write more robust and error-resistant code. Proper handling of indices is crucial in real-world applications to ensure data integrity and prevent runtime exceptions.