How to Use break and continue with forEach in Kotlin

By the end of this page, you will understand why break and continue do not work directly inside Kotlin functions like forEach and repeat, how inline functions and labeled return behave, and when to use a regular for loop instead. You will also learn practical alternatives for skipping items, stopping iteration early, and writing clear loop logic in real Kotlin code.

In Kotlin, break and continue are loop-control keywords. They only work with actual loop constructs such as:

• for
• while
• do...while

Functions like forEach and repeat may look like loops when you read them, but they are still function calls. Their bodies are lambdas, not loop bodies in the language grammar.

That difference matters:

• break means: stop the nearest real loop.
• continue means: skip to the next iteration of the nearest real loop.
• A lambda passed to forEach is not itself a loop.

So this does not work:

(1..5).forEach {
    break
}

because break can only target a real loop.

What can you do instead?

Kotlin gives you a useful alternative: returns from lambdas.

-like behavior

Think of a regular loop as a treadmill with built-in control buttons:

• continue = skip this step and move to the next one
• break = stop the treadmill completely

Now think of forEach as hiring a worker to process each item one at a time. You can tell the worker, “stop what you're doing for this item” using return@forEach, but that is not the same as pressing the treadmill's break button. The worker is just inside a function call, not controlling the actual loop keyword machinery.

So:

• Real loop = you control the loop directly
• forEach lambda = you control only the current callback execution

That is why return@forEach feels like continue, but there is no direct equivalent of break there.

Real loop syntax

for (i in 1..5) {
    if (i == 2) continue
    if (i == 4) break
    println(i)
}

forEach with continue-like behavior

Use a labeled return:

(1..5).forEach {
    if (it == 3) return@forEach
    println(it)
}

Explanation

• When it == 3, return@forEach ends the current lambda call.
• forEach then moves on to the next item.
• This is the closest equivalent to continue.

forEach cannot use break

This is invalid:

Consider this example:

(1..5).forEach {
    if (it == 3) return@forEach
    println(it)
}

Step-by-step

1. 1..5 creates a range: 1, 2, 3, 4, 5
2. forEach starts calling the lambda for each value.
3. First value: it = 1
   • it == 3 is false
   • println(1) runs
4. Second value: it = 2
   • it == 3 is false
   • println(2) runs
5. Third value: it = 3
   • it == 3 is true
   • return@forEach exits the lambda for this item
   • println(it) is skipped
6. Fourth value: it = 4

Skipping invalid data during processing

val names = listOf("Ana", "", "Ben")

names.forEach {
    if (it.isBlank()) return@forEach
    println(it)
}

Useful when processing user input or CSV rows.

Searching until a match is found

Instead of forcing break into forEach, use a search function:

val userId = listOf(10, 20, 30).firstOrNull { it == 20 }

This is common in APIs and database result handling.

Validating a list of items

val allPositive = listOf(1, 2, 3).all { it > 0 }

This often replaces manual loops that would break on failure.

Processing items until a condition changes

val values = listOf(1, , , , , )
values.takeWhile { it !=  }.forEach { println(it) }

In real Kotlin projects, developers usually choose iteration style based on intent.

Common patterns

1. Use forEach for side effects on every item

users.forEach { println(it.name) }

This is good when you simply want to do something for each element.

2. Use return@forEach as a guard clause

users.forEach {
    if (!it.isActive) return@forEach
    sendEmail(it)
}

This is a common pattern for skipping invalid or irrelevant items.

3. Use filter before forEach

users
    .filter { it.isActive }
    .forEach { sendEmail(it) }

This often reads better than putting skip logic inside forEach.

4. Use firstOrNull, find, any, or all instead of manual early exit

Mistake 1: Trying to use break inside forEach

Broken code:

(1..5).forEach {
    if (it == 3) break
}

Why it fails:

• break only works in real loops.
• forEach is a function call with a lambda.

How to fix it:

• Use a for loop, or
• use a function that matches your intent, such as find or takeWhile

Mistake 2: Expecting return@forEach to stop everything

Broken expectation:

(1..5).forEach {
    if (it == 3) return@forEach
    println(it)
}

Some beginners expect the loop to stop at 3, but it does not. It only skips that one element.

Quick rules

• break works only in real loops: for, while, do...while
• continue works only in real loops
• forEach and repeat are functions, not loop keywords
• return@forEach skips the current lambda call
• return@repeat skips the current lambda call
• Use for when you need true break or continue

Common patterns

Skip current item in forEach

items.forEach {
    if (shouldSkip(it)) return@forEach
    process(it)
}

Stop early when searching

val match = items.firstOrNull { condition(it) }

Stop processing while condition is true

Can I use break inside forEach in Kotlin?

No. break only works with actual loop statements like for and while, not inside lambdas passed to functions.

How do I simulate continue in Kotlin forEach?

Use a labeled return:

return@forEach

This skips the rest of the current lambda execution.

How do I stop a forEach early in Kotlin?

Usually, you should use a for loop instead. If your goal is searching or checking a condition, use functions like find, firstOrNull, any, or takeWhile.

Does inline allow break and continue inside lambdas?

• for loop — real loop syntax that supports break and continue
• while loop — another real loop construct with direct loop control
• labeled returns — used to exit a lambda like return@forEach
• inline functions — important for understanding non-local and local returns in Kotlin
• lambda expressions — forEach and repeat use lambdas as callback bodies
• map — used when transforming collections instead of looping manually
• filter — useful for excluding items before iteration
• find / firstOrNull — better choices when you want to stop after finding a match
• any / all — expressive alternatives for condition checks across collections
• takeWhile — processes items only while a condition remains true