How do I return early using return, break, and continue in Kotlin loops?

By I Wayan Saryada in Kotlin 0 Comment

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!

How do I use the “return” keyword in Java?

By I Wayan Saryada in Basic, Core API 5 Comments

The return keyword is used to return from a method when its execution is complete. When a return statement is reached in a method, the program returns to the code that invoked it.

A method can return a value or reference type or does not return a value. If a method does not return a value, the method must be declared void and it doesn’t need to contain a return statement.

If a method declare to return a value, then it must use the return statement within the body of method. The data type of the return value must match the method’s declared return type.

package org.kodejava.basic;

public class ReturnDemo {

    public static void main(String[] args) {
        int z = ReturnDemo.calculate(2, 3);
        System.out.println("z = " + z);

        Dog dog = new Dog("Spaniel", "Doggie");
        System.out.println(dog.getDog());
    }

    public static int calculate(int x, int y) {
        // return an int type value
        return x + y;
    }

    public void print() {
        System.out.println("void method");

        // it does not need to contain a return statement, but it
        // may do so
        return;
    }

    public String getString() {
        return "return String type value";

        // try to execute a statement after return a value will
        // cause a compile-time error.
        //
        // String error = "error";
    }
}

class Dog {
    private String breed;
    private String name;

    Dog(String breed, String name) {
        this.breed = breed;
        this.name = name;
    }

    public Dog getDog() {
        // return Dog type
        return this;
    }

    public String toString() {
        return "breed: " + breed.concat("name: " + name);
    }
}

Sometimes learning Java can be challenging, but the main thing is to remember that you can find any help on our website. Just be dedicated and passionate about what you do. If you are still at university, a pay for essay service EssayWritingService can be of any assistance for you.