Schleifen in Kotlin

Kotlin unterstützt verschiedene Arten von Schleifen, die es Entwicklern ermöglichen, eine Gruppe von Anweisungen mehrmals auszuführen.

For-Schleife

Die For-Schleife in Kotlin durchläuft alle Elemente einer Kollektion. Die formale Syntax der For-Schleife in Kotlin ist wie folgt.

fun main() {
    for (variable in sequence) {
         // Auszuführende Anweisungen
    }
}

Variable ist der Name der Variablen, die für jedes Element in der Sequence verwendet wird, über die iteriert wird. Innerhalb des Schleifenkörpers können alle Anweisungen ausgeführt werden, die für jedes Element in der Sequenz ausgeführt werden sollen.

Im folgenden Beispiel werden Quadrate aller Zahlen von 1 bis 9 mittels einer for-Schleife berechnet:

fun main() {
    for(n in 1..9) {
        print("${n * n} \t")
    }
}

Und das funktioniert wie folgt:

for(n in 1..9): Hier beginnt die for-Schleife, die den Bereich 1 bis einschließlich 9 durchläuft.

println(„${n * n}“): Bei jedem Durchlauf der Schleife (Iteration der Schleife) wird der aktuelle Wert von n quadriert (mit n * n) und mithilfe der Funtrion print() in Konsole ausgegeben.

Es ist möglich, Schleifen ineinander zu verschachteln.

fun main() {
for(i in 1..9){
    for(j in 1..9){
        print("${i * j} \t")
    }
    println()
    }
}

Zusammengefasst führt dieses Programm die folgenden Schritte aus:

1. Die äußere Schleife durchläuft die Zahlen von 1 bis 9 (einschließlich) für die Variable i.
2. Für jeden Wert von i wird die innere Schleife gestartet und durchläuft die Zahlen von 1 bis 9 (einschließlich 9) für die Variable j.
3. Für jedes Paar i und j wird ihr Produkt berechnet und in der Tabelle ausgegeben.
4. Nachdem die innere Schleife für alle Werte von j durchlaufen wurde, wird eine neue Zeile hinzugefügt, und die Ausgabe geht zur nächsten Zeile der Multiplikationstabelle über.
5. Das Programm endet, nachdem alle Zeilen der Multiplikationstabelle für die Zahlen von 1 bis 9 ausgegeben wurden.

Es gibt auch weitere Arten von For-Schleifen, die in Kotlin verwendet werden können:

For-Schleife mit einem Index: In dieser Art von For-Schleife wird ein Index verwendet, um über eine Sammlung von Elementen zu iterieren und gleichzeitig den Index jedes Elements abzurufen.

fun main() {
// For-Schleife mit einem Index
    val numbers = listOf(1, 2, 3, 4, 5)

    for (i in numbers.indices) {
        println("Element at index $i is ${numbers[i]}")
    }
}

For-Schleife mit einer Schrittweite: In dieser Art von For-Schleife kann eine Schrittweite angegeben werden, um die Anzahl der Schleifendurchläufe zu steuern.

fun main() {
// For-Schleife mit einer Schrittweite
    for (i in 1..10 step 2) {  // Hier werden die Zahlen aus dem Bereich 1 bis 10 in dem Schritt 2 ausgelesen (1, 3, 5, etc.)
        println(i)
    }
}

Und noch eine Möglichkeit die Schrittweite in Kombination mit dem Index zu benutzen:

fun main() {
// For-Schleife mit einem Index und einer Schrittweite
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    for (i in numbers.indices step 2) {
        println("Element at index $i is ${numbers[i]}")
    }
}

For-Schleife mit einer Bedingung: In dieser Art von For-Schleife kann eine Bedingung angegeben werden, um zu kontrollieren, welche Elemente in der Schleife verarbeitet werden.

fun main() {
// For-Schleife mit einer Bedingung
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    for (number in numbers) {
         if (number % 2 == 0) {
             println("$number is even")
         }
    }
}

While-Schleife

In Kotlin wird die while-Schleife verwendet, um eine Aufgabe wiederholt auszuführen, solange eine bestimmte Bedingung erfüllt ist. Die Schleife wird beendet, sobald die Bedingung nicht mehr erfüllt ist. Hier sind einige Beispiele für die Verwendung von while-Schleifen in Kotlin:

fun main() {
// While-Schleife
   var count: Int = 1
   var limit: Int = 10

   while (count <= limit) {
         println("Number: $count")
         count++ // Dasselbe wie count = count + 1
   }
}

In diesem Beispiel wird eine while-Schleife verwendet, um die Zahlen von 1 bis 10 auszugeben. Die Schleife wird ausgeführt, solange der Wert von count kleiner oder gleich limit ist.

Do..while-Schleife

In Kotlin ist die do..while-Schleife eine Kontrollstruktur, die einen Codeblock wiederholt ausführt, solange eine bestimmte Bedingung erfüllt ist. Im Gegensatz zur while-Schleife wird der Codeblock innerhalb der do..while-Schleife mindestens einmal ausgeführt, unabhängig von der Bedingung. Die Bedingung wird erst nach dem ersten Durchlauf des Codeblocks überprüft.

Hier ist die Syntax der do..while-Schleife:

do {
   // Code, der wiederholt susgeführt werden soll
} while (condition) // Bedingung

Hier ist ein Beispiel, das zeigt, wie man eine do..while-Schleife in Kotlin verwendet:

fun main() {
// Do..while-Schleife
   var count: Int = 1
   val limit: Int = 5

   do {
      println("Number: $count")
      count++
   } while (count <= limit)
}

In diesem Beispiel wird eine do..while-Schleife verwendet, um die Zahlen von 1 bis 5 auszugeben. Die Schleife wird ausgeführt, solange der Wert von count kleiner oder gleich limit ist. Da der Codeblock innerhalb der do..while-Schleife mindestens einmal ausgeführt wird, wird die Zahl 1 immer ausgegeben, selbst wenn der Wert von limit kleiner als 1 ist. Probiere das selbst aus, indem du den Wert der Variablen limit auf 0 setzt.

Steuerungsanweisungen continue und break

In Kotlin sind continue und break Steuerungsanweisungen, die innerhalb von Schleifen wie for, while oder do..while verwendet werden, um den Fluss der Schleife zu steuern.

Die continue-Anweisung wird verwendet, um den aktuellen Durchlauf der Schleife vorzeitig zu beenden und direkt mit dem nächsten Durchlauf fortzufahren. Wenn continue ausgeführt wird, wird der Rest des Codes innerhalb des Schleifenblocks für den aktuellen Durchlauf übersprungen, und die Schleife wird mit der nächsten Iteration fortgesetzt. Beispiel für die Verwendung von continue:

fun main() {
// continue-Anweisung
    for (i in 1..10) {
        if (i % 2 != 0) {
           continue
        }
        println(i)
    }
}

In diesem Beispiel wird die continue-Anweisung verwendet, um alle ungeraden Zahlen (i % 2 != 0) zu überspringen und nur gerade Zahlen zwischen 1 und 10 auszugeben.

Die break-Anweisung wird verwendet, um die gesamte Schleife vorzeitig zu beenden. Wenn break ausgeführt wird, wird die Schleife sofort abgebrochen, und der Programmfluss wird nach dem Schleifenblock fortgesetzt. Beispiel für die Verwendung von break:

fun main() {
// cbreak-Anweisung
    for (i in 1..10) {
        if (i == 5) {
            break
        }
        println(i)
    }
}

In diesem Beispiel wird eine for-Schleife verwendet, um die Zahlen von 1 bis 10 auszugeben. Die Schleife wird jedoch durch die break-Anweisung abgebrochen, sobald der Wert von i gleich 5 ist. Das bedeutet, dass die Zahlen 1 bis 4 ausgegeben werden und die Schleife dann endet.