How to Get the Current Index in a for-each Loop in Kotlin

By the end of this page, you will understand how to access an element's index while looping in Kotlin. You will learn the most common options—withIndex(), forEachIndexed(), and a classic indexed loop—and when each one is most useful.

In Kotlin, a basic for (value in collection) loop gives you direct access to each element, but not its position. This is intentional: a for-each loop focuses on values, not indexes.

When you need both the element and its position, Kotlin provides built-in tools instead of making you manage a counter manually.

The most common choices are:

• withIndex() for for loops
• forEachIndexed() for functional-style iteration
• indices or a classic range-based loop when you specifically need index-based access

Why this matters:

• Sometimes logic depends on position, such as every second item
• You may need to format output differently for the first or last item
• You may need both the index and value when processing lists

In Kotlin, the preferred approach is usually to choose the loop style that matches your intention:

• Need just values? Use for (value in collection)
• Need value and index? Use withIndex() or forEachIndexed()
• Need direct indexed access? Use indices

This keeps your code readable and avoids unnecessary manual counters.

Think of a collection like a row of lockers.

• A plain for (value in collection) loop lets you open each locker and look at what's inside.
• An indexed loop also tells you the locker number.

If you only care about the contents, the locker number does not matter. If you want to do something with every second locker, or print Item 0, Item 1, and so on, then you need both:

• the locker number = index
• the contents = value

Kotlin's withIndex() and forEachIndexed() are just convenient ways of giving you both pieces of information together.

Using withIndex()

This is the most direct Kotlin-style solution for a for loop.

val collection = listOf("a", "b", "c", "d")

for ((index, value) in collection.withIndex()) {
    if (index % 2 == 0) {
        println("Index $index contains $value")
    }
}

What this does

• withIndex() pairs each element with its index
• (index, value) uses destructuring to extract both parts
• index % 2 == 0 checks for even indexes

Output:

Index 0 contains a
Index 2 contains c

Using forEachIndexed()

val collection = listOf("a", , , )

collection.forEachIndexed { index, value ->
     (index %  == ) {
        println()
    }
}

Consider this example:

val collection = listOf("red", "blue", "green", "yellow")

for ((index, value) in collection.withIndex()) {
    if (index % 2 == 0) {
        println("$index -> $value")
    }
}

Step-by-step

1. collection contains 4 items:

   • index 0 = red
   • index 1 = blue
   • index 2 = green
   • index 3 = yellow

2. collection.withIndex() creates pairs like:

   • (0, red)
   • (1, blue)

Getting the index during iteration is common in real programs.

UI rendering

You might style alternating rows differently:

items.forEachIndexed { index, item ->
    val rowStyle = if (index % 2 == 0) "light" else "dark"
    println("Render $item with $rowStyle style")
}

Numbered lists

val tasks = listOf("Write code", "Test app", "Deploy")

for ((index, task) in tasks.withIndex()) {
    println("${index + 1}. $task")
}

Skipping or processing alternate items

val values = listOf(10, 20, 30, 40, 50)

for ((index, value) in values.withIndex()) {
    if (index % 2 == 1) {
        println()
    }
}

In real Kotlin codebases, developers usually pick the iteration style based on intent.

Common patterns

1. Prefer value-only loops when index is unnecessary

for (user in users) {
    println(user.name)
}

This is simpler and more readable.

2. Use withIndex() when writing a normal for loop

for ((index, user) in users.withIndex()) {
    println("$index: ${user.name}")
}

This is common when you want a straightforward loop with index access.

3. Use forEachIndexed() in collection pipelines

users.forEachIndexed { index, user ->
    if (user.isActive) {
        println("Active user #$index: ${user.name}")
    }
}

4. Use guard conditions with index-based logic

users.forEachIndexed { index, user ->
    if (index == 0) return
    println(user.name)
}

1. Expecting for (value in collection) to provide an index

This loop only gives you the value.

for (value in collection) {
    // no index variable exists here
}

Fix

Use withIndex() or forEachIndexed().

for ((index, value) in collection.withIndex()) {
    println(index)
}

2. Writing an invalid modulo condition

Broken code:

if (iterationNo % 2) {
    // do something
}

In Kotlin, % returns a number, not a boolean.

Fix

Compare the result explicitly:

if (index % 2 == 0) {
    // even index
}

3. Confusing iteration number with index

Indexes usually start at .

Quick reference

Value only

for (value in collection) {
    println(value)
}

Index + value with withIndex()

for ((index, value) in collection.withIndex()) {
    println("$index -> $value")
}

Index + value with forEachIndexed()

collection.forEachIndexed { index, value ->
    println("$index -> $value")
}

Index only

for (i in collection.indices) {
    println(i)
}

Every second item

Even indexes:

if (index % 2 == 0)

Odd indexes:

 (index %  == )

How do I get the index in a Kotlin for-each loop?

Use withIndex() in a for loop or forEachIndexed() in a lambda-based loop.

What is the Kotlin equivalent of Java's for (int i = 0; i < length; i++)?

Usually for (i in collection.indices) or for ((i, value) in collection.withIndex()), depending on whether you need the value directly.

How do I process every second element in Kotlin?

Use the index and test it with modulo:

if (index % 2 == 1)

or

if (index % 2 == 0)

depending on whether you want odd or even positions.

Is withIndex() better than a manual counter?

Usually yes. It is clearer, less error-prone, and more idiomatic in Kotlin.

Can I modify a list while using withIndex()?

You can read values easily, but if you need to update by position, looping over is often more appropriate.

• for loop — Basic iteration syntax in Kotlin.
• collections in Kotlin — Lists, sets, and other collection types are commonly iterated over.
• withIndex() — The standard way to get both index and value in a for loop.
• forEachIndexed() — A convenient lambda-based alternative for indexed iteration.
• ranges and until — Useful for safe index-based loops.
• modulo operator (%) — Commonly used to check even and odd indexes.
• destructuring declarations — Used in for ((index, value) in ...) syntax.
• List indexing — Important when accessing elements directly with collection[i].