How to Break Out of a ForEach Loop in Kotlin (Step-by-Step)

Kotlin developers often enjoy the clean, functional programming style that the forEach loop brings. It makes iteration concise, readable, and expressive. However, when working with real-world problems, you often need more control: skipping iterations, breaking early, or managing conditions where exiting a loop is necessary. Unlike traditional for loops, forEach does not support break and continue statements directly. This limitation leads many developers to ask: how do I stop or break out of a forEach loop in Kotlin?

This article explores the problem in detail and walks through several strategies step by step. You’ll learn why forEach doesn’t behave like a traditional loop, how to use workarounds like return@forEach, exceptions, and when to switch to regular loops. By the end, you’ll know not only the techniques but also the best practices for deciding between forEach and for.

Why You Can’t Directly Break Out of a forEach Loop in Kotlin

When developers first encounter the issue of breaking out of forEach, it often comes as a surprise. After all, in most programming languages, loops are designed with control statements like break and continue. In Kotlin, though, forEach is not technically a loop construct—it’s a higher-order function.

Understanding Higher-Order Functions

A higher-order function is one that either returns or accepts another function (lambda) as an argument. The forEach function operates on collections like lists or sets and applies the lambda to each element.

For example:

val numbers = listOf(1, 2, 3, 4)

numbers.forEach { println(it) }

This will simply print each number in the list. Behind the scenes, however, forEach is not a native loop; it’s implemented as an inline function that iterates over the collection. Because of this, break and continue don’t apply in the same way they would inside a for or while loop.

Compilation Errors

If you attempt to write code like this:

listOf(1, 2, 3, 4).forEach {

if (it == 3) break

println(it)

}

You’ll see a compilation error:

‘break’ or ‘continue’ jumps across a function or class boundary

The compiler prevents this because break is tied to loop constructs, not to higher-order function calls.

Why Does Kotlin Restrict This?

The reasoning lies in design clarity. Kotlin emphasizes functional programming constructs like immutability and lambda expressions. Allowing break inside these functions could make code behavior ambiguous or misleading. By disallowing it, Kotlin enforces a clear distinction: use functional constructs when you want functional iteration, and use traditional loops when you want control flow.

Alternative Constructs in Kotlin

Instead of relying on break, Kotlin provides alternatives:

• return@forEach for skipping to the next iteration
• Exceptions for breaking out completely
• Plain for loops for maximum control

Each approach has its place, which we’ll explore in later sections.

Key takeaway: Kotlin’s forEach is not a traditional loop but a higher-order function. That’s why you can’t directly use break or continue inside it:

Using return@forEach to Exit the Current Iteration

Sometimes, you don’t need to stop the entire loop—you just want to skip a specific element and move on. In traditional loops, you’d use continue. In Kotlin’s forEach, this is achieved using a labeled return with return@forEach.

How Labeled Returns Work

A labeled return tells Kotlin where to return from. In the context of forEach, writing return@forEach means “exit the current iteration of the forEach function and continue with the next element.”

Example:

val items = listOf(“apple”, “banana”, “cherry”, “date”)

items.forEach {

if (it.startsWith(“c”)) return@forEach

println(it)

}

Output:

apple

banana

date

Here, cherry is skipped because it matches the condition, but the loop continues with the next element.

Common Use Cases

Using return@forEach is especially useful in cases like:

• Filtering: Skipping invalid or unwanted entries while processing data
• Validation: Ignoring elements that don’t meet a requirement
• Logging: Printing only specific elements in a dataset

Difference Between return and return@forEach

It’s important to note the difference between return and return@forEach.

• return (without label) will attempt to return from the enclosing function entirely.
• return@forEach will only skip the current iteration and continue.

For example:

fun process() {

listOf(1, 2, 3).forEach {

if (it == 2) return@forEach

println(it)

}

println(“Done”)

}

Output:

1

3

Done

But if you mistakenly write return, it will exit process() completely, skipping the rest.

Advantages of Using return@forEach

• Readable and expressive for simple skipping logic
• Avoids exception handling overhead
• Stays within the functional programming style Kotlin encourages

Key takeaway: Use return@forEach when you need the equivalent of continue in a forEach loop—it lets you skip an iteration without stopping the entire loop:

Breaking Out of a forEach with runCatching, try-catch, or Exceptions

Sometimes you need more than skipping—you want to stop the loop entirely as soon as a condition is met. Since forEach doesn’t allow break, developers often rely on exceptions as a workaround.

Using Exceptions to Exit Early

One common trick is to throw an exception when the exit condition is met, and then catch it outside the loop.

class BreakException : RuntimeException()

fun main() {

try {

listOf(1, 2, 3, 4).forEach {

if (it == 3) throw BreakException()

println(it)

}

} catch (e: BreakException) {

println(“Loop exited early at 3”)

}

}

Output:

1

2

Loop exited early at 3

Why This Works

Throwing an exception stops the execution of the lambda and unwinds the stack until it’s caught. Since forEach is inline, the exception propagates immediately out of the loop.

Downsides of Using Exceptions

• Performance: Throwing exceptions is more costly than normal flow control
• Readability: Developers might not expect exceptions used for control flow
• Best Practices: Exceptions should represent “exceptional” cases, not normal logic

Alternatives with runCatching

You can also use Kotlin’s runCatching or Result to wrap execution:

runCatching {

listOf(“A”, “B”, “C”).forEach {

if (it == “B”) throw BreakException()

println(it)

}

}.onFailure { println(“Exited early”) }

Output:

A

Exited early

When Is This Useful?

• When iterating large collections where early exit saves significant processing time
• When you’re forced to use forEach in a library context but still need exit control
• When breaking early is a rare condition (making the exception feel justified)

Key takeaway: Exceptions can simulate breaking out of forEach, but they should be used sparingly. For readability and performance, prefer regular loops unless exceptions are truly justified:

Replacing forEach with a for Loop for More Control

While forEach is elegant, sometimes it’s simply the wrong tool. If you find yourself trying too hard to manipulate it into behaving like a traditional loop, the easiest solution is often to just use a for loop.

Advantages of Using for Loops

• Direct support for break and continue
• Better readability when early exits are common
• Familiarity for developers from other languages

Example:

for (item in listOf(“red”, “green”, “blue”, “yellow”)) {

if (item == “blue”) break

println(item)

}

Output:

red

green

Comparison Table: forEach vs for

Feature	forEach	for Loop
Conciseness	Short and functional	Slightly longer syntax
Readability	Clear for simple transformations	Clearer for complex conditions
break / continue	Not supported directly	Fully supported
Performance	Similar	Similar (sometimes faster)
Best use case	Functional iteration	Controlled iteration

When to Switch from forEach to for

• If you need frequent breaks or continues
• If you’re writing business logic where flow control is essential
• If exceptions feel like hacks just to escape a loop

By switching to a for loop, you reduce mental overhead for anyone reading your code. It makes the intention obvious: you want explicit control over the loop’s flow.

Key takeaway: When you need traditional loop control, use a for loop. It avoids hacks, improves clarity, and ensures your intent is immediately clear:

Best Practices: When to Use forEach vs for Loops in Kotlin

Deciding between forEach and for comes down to context and intent. Both have their place in Kotlin, but knowing when to use each makes your code cleaner and easier to maintain.

When to Use forEach

• When writing concise, functional-style code
• For simple transformations, such as printing or applying actions
• When skipping is minimal and doesn’t require loop exits

Example:

listOf(“John”, “Jane”, “Jake”).forEach { println(it.uppercase()) }

When to Use for

• When early exits (break) or skips (continue) are necessary
• When clarity is more important than conciseness
• When performance may be impacted by unnecessary exception handling

Example:

for (i in 1..10) {

if (i % 2 == 0) continue

if (i > 7) break

println(i)

}

Guidelines for Decision-Making

Question	Best Choice
Do I need to break early?	for
Do I only need to skip items occasionally?	forEach
Is the operation functional in nature?	forEach
Is clarity and maintainability crucial?	for

By asking these questions, you can quickly determine which loop structure makes more sense in your context.

Key takeaway: Use forEach for functional-style iteration and simplicity. Switch to for when loop control is essential for clarity and correctness:

Conclusion

Kotlin’s forEach is powerful for functional-style programming but isn’t suited for traditional loop control. If you need to skip elements, return@forEach works well. If you must exit early, exceptions can help but should be avoided for performance and clarity reasons. Ultimately, the traditional for loop remains the most reliable choice when control flow is essential.

By understanding the strengths and limitations of both approaches, you’ll be able to write code that’s both efficient and easy to maintain.

FAQs

Can I use break inside a forEach in Kotlin?

No, break is not allowed inside forEach because it’s a function, not a loop construct.

What does return@forEach do?

It skips the current iteration and continues with the next element, similar to continue.

Is using exceptions to break out of forEach good practice?

Generally no — it’s more of a workaround. Prefer a for loop if you need break.

Which is faster: forEach or for loop in Kotlin?

Both are similar in performance, but for loops can be slightly more efficient and flexible.

Should I always avoid forEach if I need break?

Yes, in most cases a for loop is cleaner when loop control is necessary.