In Kotlin, you can use return, break, and continue inside loops to control the flow. Here’s a detailed explanation and examples for each:

1. Using return

The return statement is used to terminate the execution of an enclosing function or lambda expression, and optionally return a value from it.
If used inside a loop, it will exit the entire function, not just the loop.

Example:

fun findNumber(numbers: List<Int>, target: Int): Boolean {
    for (number in numbers) {
        if (number == target) {
            return true // Terminates the function and returns true
        }
    }
    return false // If no match is found, this is executed after the loop
}

2. Using break

The break statement is used to exit the current loop (for, while, or do-while). The loop terminates immediately, and execution continues with the statement after the loop.

Example:

fun printUntilFive(numbers: List<Int>) {
    for (number in numbers) {
        if (number == 5) {
            break // Exit the loop when number is 5
        }
        println(number)
    }
    println("Loop ended.")
}

Output (for printUntilFive(listOf(1, 2, 3, 5, 6))):

1
2
3
Loop ended.

3. Using continue

The continue statement skips the current iteration of the loop, jumping to the next iteration immediately. It does not terminate the loop.

Example:

fun skipOddNumbers(numbers: List<Int>) {
    for (number in numbers) {
        if (number % 2 != 0) {
            continue // Skip the current iteration for odd numbers
        }
        println(number) // This will only print even numbers
    }
}

Output (for skipOddNumbers(listOf(1, 2, 3, 4, 5, 6))):

2
4
6

---

Using return, break, and continue in Nested Loops

In Kotlin, when dealing with nested loops, these keywords operate on the innermost enclosing loop by default. To modify this behavior, you can use labels.

Example with Labels:

fun labeledExample() {
    outer@ for (i in 1..3) {
        for (j in 1..3) {
            if (i == 2 && j == 2) {
                break@outer // Exits the outer loop entirely
            }
            println("i = $i, j = $j")
        }
    }
}

Output:

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1

---

Summary

• return: Exits the entire function or lambda.
• break: Exits the current loop.
• continue: Skips the current iteration and moves to the next.
• Labels (e.g., @outer): Allow you to terminate or skip specific labeled loops in nested cases.

These keywords provide a powerful way to control Kotlin loop flows efficiently!