Jetzt anmelden...

Login
Passwort
Registrieren

Java Tutorial #8

Schleifen in Java verständlich erklärt

Schleifenstrukturen gehören zu den wichtigsten Grundlagen in der Programmierung überhaupt. Es gibt unterschiedliche Schleifentypen, die je nach Einsatzzweck sinnvoll gewählt werden können. Schauen wir uns diese nun genauer an.

Kommentare [0]

Stefan 22.09.2018

Infos zum Artikel

Kategorie Java
Autor Stefan
Datum 22.09.2018

Thema in Kurzform

  • Schleifen (engl. loops) ermöglichen es uns, bestimmte Anweisungen beliebig oft zu wiederholen, ohne dabei den entsprechenden Code jedes Mal neu schreiben zu müssen.
  • Es gibt mehrere verschiedene Schleifentypen, die je nach Einsatzweck sinnvoll gewählt werden können.

for-Schleife

Die for-Schleife ist der Klassiker unter den Schleifen. Eine for-Schleife besteht aus vier Teilen. Diese sind:

  • Schleifenvariable Definition: Wir definieren die Schleifenvariable mit einem Startwert.
  • Schleifenbedingung: Die Schleife wird solange wiederholt, wie die Prüfung eines booleschen Ausdrucks true ergibt. Sobald die Prüfung false ist, wird die Schleife beendet.
  • Veränderung der Schleifenvariable: Nach jedem Schleifendurchlauf wird die Schleifenvariable verändert (zum Beispiel durch Hoch- oder Runterzählen um 1).
  • Schleifenkörper: Beinhaltet die Anweisungen, die zu jedem Durchlauf der Schleife ausgeführt werden.

Diese vier Bausteine der for-Schleife sehen in der Java-Syntax konkret so aus:

Java for-Schleife Aufbau Grafik

Der Startwert der Schleifenvariablen i ist 0. Die Schleifenbedingung lautet i < 5, das heißt: Die Schleife wird solange wiederholt, wie i kleiner als 5 ist. i wird nach jedem Schleifendurchlauf um +1 erhöht.

Die Schleife in unserem Beispiel bewirkt, dass die Anweisung System.out.println(i); insgesamt fünfmal ausgeführt wird. i hat bei jedem Durchlauf einen anderen Wert. Das Ergebnis sieht auf der Konsole wie folgt aus:

0
1
2
3
4

In einem Aktivitätsdiagramm lässt sich die Logik dahinter so darstellen:

Java for-Schleife Grafik

Dadurch, dass wir die gesamte Steuerung der Schleife in einer Zeile, dem Schleifenkopf, vornehmen können, ist die for-Schleife besonders übersichtlich. Sie eignet sich außerdem bestens, wenn wir wissen, wie oft ein Programmvorgang wiederholt werden soll.

Endlosschleife

Hüten Sie sich vor Schleifen, die Ihren Code ins Verderben führen, da sie niemals enden! Was glauben Sie, ist das Resultat des folgenden Codes:

for(int i = 0 ; i < 1; i--){
    System.out.println("Ich bin ein Durchlauf");
}

Richtig: Da die Bedingung i < 1 immer true ist und bleibt, wird die Schleife ewig laufen! Wir sitzen in einer Endlosschleife fest, aus der aus kein Entrinnen gibt.

Passen sie also immer gut auf Ihre Schleifenvariable auf, damit die Schleifenbedingung irgendwann auch erfüllt werden kann.

while-Schleife

Die while-Schleife eignet sich gut, wenn wir zu Beginn noch nicht wissen, wieviele Schleifendurchläufe benötigt werden. Um eine while-Schleide zu starten, benutzen wir das Schlüssekwort while und schreiben direkt dahinter die Schleifenbedingung in runden Klammern. Es folgt der Schleifenkörper mit den auszuführenden Anweisungen. Hier ein praktisches Beispiel:

int number = 0;

while(number != 6){
    number =  (int) ((Math.random() * 6)+1);
    System.out.print(number + " ");
}

Am Beispiel wird die Schleife solange wiederholt, wie die Variable number nicht den Wert 6 hat. Am Ende jeder Anweisung wird der Wert von number mit Hilfe einer Zufallszahl zwischen 1 und 6 neu ermittelt. Die Schleife wird somit irgendwann enden - wir wissen aber nicht genau wann. Ein mögliches Ergebnis ist folgender Konsolenprint:

3 4 3 3 6

Der wesentliche Unterschied zur for-Schleife ist, dass bei der while-Schleife nur die Schleifenbedingung im Schleifenkopf (in den runden Klammern) steht. Die Schleifenvariable dagegen wird außerhalb der Schleifenkonstruktion definiert und die Schleifensteuerung erfolgt im Schleifenkörper.

do-while-Schleife

Die do-while-Schleife ist der while-Schleife recht ähnlich. Der Unterschied ist aber, dass die Prüfung zur Wiederholung erst am Ende, nach einem Schleifendurchlauf erfolgt. Das hat zur Konsequenz, dass die Schleife in jedem Fall mindestens einmal durchlaufen wird:

Java do while Schleide Grafik

Im Gegensatz zu anderen Schleifentypen gibt es bei der do-while-Schleife also auf jeden Fall eine Code-Runde gratis.

Unser Zufallszahlen-Beispiel von oben sieht in einer do-while-Schleife dann so aus:

int number = 6;

do{
    number =  (int) ((Math.random() * 6)+1);
    System.out.print(number + " ");
}
while(number != 6);

Syntaktisch hat sich einiges getan: Der auszuführende Code-Block wird nun vom Schlüsselwort do eröffnet, während am Ende while mit der Prüfung zur Wiederholung in runden Klammern steht.

Es spielt nun keine Rolle, ob die Schleifenbedingung zu Beginn erfüllt ist oder nicht, wenn es darum geht, dass der Code-Block mindestens einmal ausgeführt werden soll. Genau das ist in unserem Beispiel auch der Fall: Denn obwohl die Schleifenbedingung nicht erfüllt ist (number = 6), wird die Schleife trotzdem ausgeführt. Mit einer for- oder while-Schleife hätten wir keinen einzigen Schleifendurchlauf bekommen, da dort die Prüfung vor dem ersten Schleifendurchlauf steht.

foreach-Schleife

Die foreach-Schleife wurde speziell dafür erfunden, die einzelnen Elemente einer Sammlung (z.B. eines Arrays) zu durchlaufen. Für jedes dieser Elemente wird die immer gleiche Anweisungen ausgeführt, wie sie im Schleifenkörper beschrieben ist.

Die allgemeine Syntax sieht wie folgt aus:

Java foreach Schleide Grafik

Nach dem Schlüsselwort for schreiben wir in die runden Klammern nacheinander den Datentyp der Arrays-Elemente. Anschließend folgt die Benennung der Schleifenvariablen (hier: sV) und nach dem Doppelpunkt der Name des Arrays. Die geschweiften Klammern { } umschließen den Schleifenkörper mit den Schleifenanweisungen.

Es gibt soviele Schleifendurchläufe wie es Elemente im Array gibt und bei jedem Durchlauf wird die Schleifenvariable sV mit dem Wert desjenigen Array-Elements belegt, das gerade an der Reihe ist. Beim ersten Durchlauf wird der Wert des ersten Array-Elements in die Schleifenvariable sV kopiert. Beim zweiten Durchlauf wird der Wert des zweiten Array-Elements in sV kopiert und so weiter. Auf diese Weise können wir auf allen Elementen eines Arrays dieselbe Anweisung durchführen.

Hier ein konkretes Beispiel:

String[] familien = {"Lannister", "Stark", "Targaryen", "Bolton", "Tyrell"};

for(String sV : familien){
    System.out.println(sV);
}

Nachdem wir zunächst ein Array aus Strings mit dem Namen familien und fünf Elementen definiert haben, lassen wir es in einer foreach-Schleife durchlaufen. Bei jedem der fünf Schleifendurchläufe wird jeweils das nächste Array-Elemente nacheinander in die Schleifenvariable kopiert und entsprechend auf der Konsole geprinted.

Verschachtelte Schleifen

Wenn im Schleifenkörper eine (oder mehrere) andere Schleifen stehen, sprechen von inneinander verschachtelten Schleifen. Theoretisch können wir beliebig oft verschachteln. Der Einfachheit halber beschränken wir uns hier aber auf eine einfache Verschachtelung mit zwei Schleifen. Bei einer einfachen Verschachtelung haben wir immer eine äußere und eine innere Schleife. Hier ein Beispiel, wie Sie es oft finden:

for(int i = 1; i<4; i++){ // äußere Schleife
      for(int y = 1; y<4; y++){ // innere Schleife
          System.out.println(i + " " + y);
      }
}

Was läuft hier ab?

Der Code läuft in den ersten Durchlauf der äußeren Schleife, wo die innere Schleife komplett durchlaufen wird. Danach geht es in den zweiten Durchlauf der äußeren Schleife, worin wieder die innere Schleife von Neuem durchlaufen wird. Dieses Spiel geht solange weiter, bis die äußere Schleife beendet wird. Innerhalb der inneren Schleife wird mit System.out.println der aktuelle Wert der beiden Schleifenvariablen i und y auf der Konsole geprinted:

1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3

Zur besseren Veranschaulichung sind die einzelnen Schritte in der folgenden Tabelle gelistet:

äußere Schleife innere Schleife Variable i Variable y
Erster Durchgang erster Durchgang 1 1
zweiter Durchgang 1 2
dritter Durchgang 1 3
Zweiter Durchgang erster Durchgang 2 1
zweiter Durchgang 2 2
dritter Durchgang 2 3
Dritter Durchgang erster Durchgang 3 1
zweiter Durchgang 3 2
dritter Durchgang 3 3

Verschachtelte Schleifen bei mehrdimensionalen Arrays

Der volle Nutzen von verschachtelten Schleifen zeigt sich in der Arbeit mit mehrdimensionalen Arrays. Sehen wir uns ein kleines 2D-Array an:

char[][] letters = {{'a', 'A'}, {'b', 'B'}, {'c', 'C'}};

Das zweidimensionale Beispiel-Array hat insgesamt drei weitere Arrays als Elemente, wovon jedes wiederum zwei char-Elemente hält. Um alle char-Elemente (insgesamt 6) zu fassen, schreiben wir die Schleifenkonstruktion wie folgt:

// Array definieren....

for(int i = 0; i < letters.length; i++){
    for(int y = 0; y < letters[i].length; y++){
        System.out.print(letters[i][y] + " ");
    }
    System.out.println("");
}

Die äußere Schleife wird so oft wiederholt, wie das Array auf der ersten Ebene Elemente hat (letters.length), also dreimal. Die innere Schleife kümmert sich dann nacheinander um die char-Elemente des aktuellen char-Arrays, das an der Reihe ist, und wird sentsprechend seiner Länge wiederholt (letters[i].length). Der Output auf der Java-Konsole ist dann erwartungsgemäß:

a A
b B
c C

continue und break

Die beiden Anweisungen continue und break können innerhalb von Schleifen eingesetzt werden, um einen Schleifendurchlauf bzw. die gesamte Schleife vorzeitig zu beenden.

continue

Der Einsatz von continue innerhalb einer Schleife sorgt für den Abbruch des aktuellen Schleifendurchlaufs:

for(int i = 0 ; i < 5; i++){
    if(i == 3){
        continue;
    }
    System.out.print(i + " ");
}

Ausgabe:

0 1 2 4

Es fehlt die 3! Der Grund: Wenn die Schleifenvariable i den Wert 3 annimmt, wird die Anweisung continue ausgeführt, womit der aktuelle Schleifendurchlauf sofort beendet wird und der nächste startet. Deshalb kommt es beim Durchlauf mit i == 3 nicht zum System.out.print.

break

Im Gegensatz zu continue beendet break erbarmungslos sofort die ganze Schleife. Ersetzen wir in unserem Schleifenbeispiel einmal continue mit break und sehen, was passiert:

for(int i = 0 ; i < 5; i++){
    if(i == 3){
        break;
    }
    System.out.print(i + " ");
}

Da die Schleife mitten im vierten Durchlaufen (i == 3) beendet wird, sieht das Ergebnis auf der Java-Konsole so aus:

0 1 2

Übungen

einfach

Richtig oder falsch?
Wenn wir break in einer while-Schleife einsetzen, wird der aktuelle Schleifendurchlauf abgebrochen und der nächste Schleifendurchlauf gestartet!?

Lösung ein-/ausblenden

mittel

Was wird auf der Konsole ausgegeben?

boolean runs = true;
    for(int i = 0; i < 5; i++){
        while(runs){
            System.out.println(i);
            if(i > -1){
                runs = false;
            }
         }
    }
Lösung ein-/ausblenden

schwer

Wie oft wird die Zahl 2 auf der Konsole geprinted?

int[] values = { 10, 30, 50 };
    for( int val : values ){
        int x = 0;
        while(x<values.length){
            System.out.println(x+" "+val);
            x++;
        }
}

A. kein Mal
B. einmal
C. zweimal
D. dreimal
E. viermal

Lösung ein-/ausblenden

Kommentar schreiben

Nur angemeldete und aktivierte Benutzer können kommentieren.

Alle Kommentare

Es gibt bislang noch keine Kommentare zu diesem Thema.

switch/ case Anweisung

Benötigen wir eine Unterscheidung nach vielen Fällen empfehlen sich switch-case-Statements.

Initializer

Eher selten aber praktisch!

toString() Methode

Lernen Sie hier, wie Sie die toString() Methode korrekt einsetzen

FALCONBYTE.NET

Handmade with 🖤️

© 2018, 2019 Stefan E. Heller

Impressum | Datenschutz

facebook programmieren lernen twitter programmieren lernen youtube programmieren lernen