Ein Leitfaden für Java-Schleifen

Ein Leitfaden zu Java Loops

1. Überblick

In diesem Artikel betrachten wir einen Kernaspekt der Java-Sprache - das wiederholte Ausführen einer Anweisung oder einer Gruppe von Anweisungen - mithilfe von Schleifen.

2. Einführung in Loops

In Programmiersprachenlooping is a feature which facilitates the execution of a set of instructions until the controlling Boolean-expression evaluates to false.

Java bietet verschiedene Arten von Schleifen, um jedem Programmierbedarf gerecht zu werden. Jede Schleife hat ihren eigenen Zweck und einen geeigneten Anwendungsfall.

Hier sind die Arten von Schleifen, die wir in Java finden können:

Einfachefor-Schleife
Verbessertefor-each-Schleife
While Schleife
Do-While Schleife

3. Einfachefor Schleife

Einefor-Schleife ist eine Steuerstruktur, mit der wir bestimmte Operationen wiederholen können, indem wir einen Schleifenzähler inkrementieren und auswerten.

Vor der ersten Iteration wird der Schleifenzähler initialisiert, dann wird die Bedingungsbewertung durchgeführt, gefolgt von der Schrittdefinition (normalerweise eine einfache Inkrementierung).

Die Syntax derfor-Schleife lautet:

for (initialization; Boolean-expression; step)
  statement;

Sehen wir uns das in einem einfachen Beispiel an:

for (int i = 0; i < 5; i++) {
    System.out.println("Simple for loop: i = " + i);
}

Die infor verwendeteninitialization,Boolean-expression, undstep sindoptional. Hier ist ein Beispiel für eineinfinite for-Schleife:

for ( ; ; ) {
    // Infinite for loop
}

3.1. Beschriftetefor-Schleifen

Wir können auchfor Schleifen beschriften. Es ist nützlich, wenn wir für Schleifen verschachtelt sind, damit wirbreak /continue aus einer bestimmtenfor-Schleife entfernen können:

aa: for (int i = 1; i <= 3; i++) {
    if (i == 1)
      continue;
    bb: for (int j = 1; j <= 3; j++) {
        if (i == 2 && j == 2) {
            break aa;
        }
        System.out.println(i + " " + j);
    }
}

4. Verbessertefor-Schleife

Seit Java 5 haben wir eine zweite Art vonfor-Schleife namensenhanced forwhich, die es einfacher macht, über alle Elemente in einem Array oder einer Sammlung zu iterieren.

Die Syntax derenhanced for-Schleife lautet:

for(Type item : items)
  statement;

Da diese Schleife im Vergleich zum Standard für die Schleife vereinfacht ist, müssen beim Initialisieren einer Schleife nur zwei Dinge deklariert werden:

Das Handle für ein Element, über das wir gerade iterieren
Das Quellarray / die Quellensammlung, die wir iterieren

Daher können wir sagen:For each element in items, assign the element to the item variable and run the body of the loop.

Schauen wir uns das einfache Beispiel an:

int[] intArr = { 0,1,2,3,4 };
for (int num : intArr) {
    System.out.println("Enhanced for-each loop: i = " + num);
}

Wir können es verwenden, um verschiedene Java-Datenstrukturen zu durchlaufen:

Wenn einList<String> list-Objekt gegeben ist, können wir es wiederholen:

for (String item : list) {
    System.out.println(item);
}

Wir können in ähnlicher Weise über einSet<String> set iterieren:

for (String item : set) {
    System.out.println(item);
}

Und mit einemMap<String,Integer> map können wir auch darüber iterieren:

for (Entry entry : map.entrySet()) {
    System.out.println(
      "Key: " + entry.getKey() +
      " - " +
      "Value: " + entry.getValue());
}

4.1. Iterable.forEach()

Seit Java 8 können wir For-Each-Schleifen auf etwas andere Weise nutzen. Wir haben jetzt eine dedizierteforEach()-Methode in derIterable-Schnittstelle, die einen Lambda-Ausdruck akzeptiert, der eine Aktion darstellt, die wir ausführen möchten.

Intern delegiert es den Job einfach an die Standardschleife:

default void forEach(Consumer action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

Schauen wir uns das Beispiel an:

List names = new ArrayList<>();
names.add("Larry");
names.add("Steve");
names.add("James");
names.add("Conan");
names.add("Ellen");

names.forEach(name -> System.out.println(name));

**5. While Schleife**

Diewhile-Schleife ist die grundlegendste Schleifenanweisung von Java. Es wiederholt eine Anweisung oder einen Anweisungsblockwhile, wobei das steuerndeBoolean-expression wahr ist.

Die Syntax derwhile-Schleife lautet:

while (Boolean-expression)
    statement;

The loop’s Boolean-expression is evaluated before the first iteration of the loop - Dies bedeutet, dass die Schleife möglicherweise nicht einmal ausgeführt wird, wenn die Bedingung mit false bewertet wird.

Schauen wir uns ein einfaches Beispiel an:

int i = 0;
while (i < 5) {
    System.out.println("While loop: i = " + i);
}

**6. Do-While Schleife**

Die do-while-Schleife funktioniert genauso wie die while-Schleife, außer dassthe first condition evaluation happens after the first iteration of the loop:

do {
    statement;
} while (Boolean-expression);