Kotlin Array slice Function

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

The slice function in Kotlin is used to create a list containing elements from specified indices of an array. This function is part of the Kotlin standard library and provides a straightforward way to extract a subset of elements from an array.

Introduction
slice Function Syntax
Understanding slice
Examples
- Basic Usage
- Using slice with Custom Types
- Handling Out of Bounds
Real-World Use Case
Conclusion

Introduction

The slice function allows you to create a list that contains elements from the original array based on a given set of indices. This is useful for extracting subarrays or specific elements without modifying the original array.

slice Function Syntax

The syntax for the slice function is as follows:

fun <T> Array<out T>.slice(indices: Iterable<Int>): List<T>

Parameters:

indices: An iterable of integers representing the indices of elements to be included in the resulting list.

Returns:

A list containing the elements from the specified indices of the original array.

Understanding slice

The slice function extracts elements from an array based on the provided indices and returns them as a list. The original array remains unchanged. This function is useful for creating subarrays or lists with selected elements.

Examples

Basic Usage

To demonstrate the basic usage of slice, we will create an array of integers and extract elements from specified indices.

Example

fun main() {
    val numbers = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val sliced = numbers.slice(listOf(2, 4, 6))
    println("Original array: ${numbers.joinToString()}")
    println("Sliced list: ${sliced.joinToString()}")
}

Output:

Original array: 1, 2, 3, 4, 5, 6, 7, 8, 9
Sliced list: 3, 5, 7

Using `slice` with Custom Types

This example shows how to use slice 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),
        Person("Rahul", 28),
        Person("Amit", 35)
    )

    val sliced = people.slice(listOf(0, 2, 4))
    println("Original array: ${people.joinToString()}")
    println("Sliced list: ${sliced.joinToString()}")
}

Output:

Original array: Person(name='Ravi', age=25), Person(name='Anjali', age=30), Person(name='Priya', age=22), Person(name='Rahul', age=28), Person(name='Amit', age=35)
Sliced list: Person(name='Ravi', age=25), Person(name='Priya', age=22), Person(name='Amit', age=35)

Handling Out of Bounds

This example demonstrates how to handle cases where the specified indices are out of bounds.

Example

fun main() {
    val numbers = arrayOf(1, 2, 3, 4, 5)
    try {
        val sliced = numbers.slice(listOf(0, 5))
        println("Sliced list: ${sliced.joinToString()}")
    } catch (e: IndexOutOfBoundsException) {
        println("Error: ${e.message}")
    }
}

Output:

Error: Index 5 out of bounds for length 5

Real-World Use Case

Extracting Specific Elements

In real-world applications, the slice function can be used to extract specific elements from a dataset for further processing or analysis.

Example

fun main() {
    val dataPoints = arrayOf(10.5, 20.3, 30.7, 40.2, 50.1, 60.8, 70.6)
    val selectedPoints = dataPoints.slice(listOf(1, 3, 5))

    // Perform analysis on the selected points
    val average = selectedPoints.average()
    println("Selected data points: ${selectedPoints.joinToString()}")
    println("Average of selected points: $average")
}

Output:

Selected data points: 20.3, 40.2, 60.8
Average of selected points: 40.43333333333333

Conclusion

The slice function in Kotlin is a convenient method for creating a list of elements from an array based on specified indices. It provides a simple way to extract subarrays and handle cases where specific elements need to be selected. By understanding and using this function, you can effectively manage array slicing and element selection operations in your Kotlin applications.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide