1. Introduction

When working as developers, we sometimes need to iterate over a collection or array, starting from a specific index position. In such cases, we can use a for loop to achieve this.

In this article, we’ll explore different methods for starting a for loop from a given index in Kotlin.

2. Using the drop() Method

The simplest way to achieve our goal is to use the drop() method. This method accepts an integer n that permits us to skip the first n elements in a list:

@Test
fun `start for loop from given index using the drop method`() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val startIndex = 2

    val result = numbers.drop(startIndex)

    assertEquals(listOf(3, 4, 5), result)
}

In this example, we use the drop() method that returns a new list that contains all elements of the original list except the first two elements as dictated by the value of startIndex.

3. Using the Range Operator

We could also start a for loop from a given index by using the range operator. The range operator in Kotlin is represented by the .. operator:

@Test
fun `start for loop from given index with range operator`() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val startIndex = 2
    val result = mutableListOf<Int>()

    for (i in startIndex..numbers.lastIndex) {
        result.add(numbers[i])
    }

    assertEquals(listOf(3, 4, 5), result)
}

From the code above, we begin iterating a list of numbers from index position 2. We use the range operator to start the for loop from the index position equal to 2 and iterate over the remaining elements in the list. The lastIndex property in the for loop returns the index of the last element in the list.

4. Using the withIndex() Method

Another way to start a for loop from a given index is by using the withIndex() method. This method returns an iterable of indexed values:

@Test
fun `start for loop from given index using withIndex method`() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val startIndex = 2
    val result = mutableListOf<Pair<Int, Int>>()

    for ((index, value) in numbers.withIndex().drop(startIndex)) {
        result.add(index to value)
    }

    assertEquals(listOf(2 to 3, 3 to 4, 4 to 5), result)
}

This code shows how to iterate over a list of numbers starting from an index position of 2. Furthermore, we use the withIndex() method to get an iterable of indexed values from the list. Finally, we use the drop() method to skip over the first two elements as per our starting index position.

From this example, notice that the starting index position of the resulting list isn’t 0. This is because we are applying the drop() method after returning an iterable of indexed list values. If we apply this drop() method before the withIndex() method, we will obtain a list starting from index position 0:

@Test
fun `start for loop from given index using withIndex method after drop() method `() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val startIndex = 2
    val result = mutableListOf<Pair<Int, Int>>()

    for ((index, value) in numbers.drop(startIndex).withIndex()) {
        result.add(index to value)
    }

    assertEquals(listOf(0 to 3, 1 to 4, 2 to 5), result)
}

5. Using the forEachIndexed() Method

Alternatively, we can use the forEachIndexed() method as a way to iterate over a list from a given index. It allows us to loop through elements, along with their indices:

@Test
fun `start for loop from given index using forEachIndexed() method`() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val startIndex = 2
    val result = mutableListOf<Pair<Int, Int>>()

    numbers.drop(startIndex).forEachIndexed { index, value ->
        result.add(index to value)
    }

    assertEquals(listOf(0 to 3, 1 to 4, 2 to 5), result)
}

In this example, we use the drop() method to skip over the first two elements of the list, according to our starting index position. Subsequently, we use the forEachIndexed() method to iterate the remaining list elements along with their indices.

6. Conclusion

In this article, we’ve explored various ways to begin a for loop from a precise index position. To begin with, we looked at using the drop() method to skip over a given number of elements. Then, we looked at other techniques for iterating, such as the range() and withIndex() methods. Finally, we explored the forEachIndexed() method that helps us to iterate over the elements of a collection along with their indices.

As always, the source code is available over on GitHub.

Comments are closed on this article!