07 Java – Schleifen

Schleifen führen einen bestimmten Code-Abschnitt so lange aus, bis ein bestimmter Zustand erreicht ist. Dieser Zustand wird hier über eine Bedingung ermittelt. Solange die Bedingung zutrifft, wird der Schleifenrumpf ausgeführt. Alle Schleifen können die Keywords break und continue verwenden. Weitere Keywords werden in den jeweiligen Abschnitten beschrieben. Schleifen können in die folgenden 4 Arten unterteilt werden.

for-Schleife
while-Schleife
do-while-Schleife
for-each-Schleife

for-Schleife

Die for-Schleife wird auch als Zählschleife bezeichnet. Sie verwendet das Keyword for. Der Kopf der Schleife besteht aus 3 Teilen, die durch Semikolons getrennt sind.

for (inizialisation; condition; in- or decrement) {
    // Code...
}

Schleifenteil	Beschreibung
Initialisierung	Hier werden alle Variablen initialisiert, die im Schleifenrumpf benötigt werden.
Bedingung	Die Bedingung prüft, ob ein gewisser Zustand erreicht ist. Solange die Bedingung erfüllt ist, wird der Schleifenrumpf ausgeführt.
In- bzw. Dekrement	Nachdem der Rumpf ausgeführt wurde, wird die Schleifenvariable erhöht oder verringert.

Folgendes Beispiel zeigt die einfachste Form der for-Schleife, welche die Zahlen von 1 bis 10 auf der Konsole ausgibt.

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

Die Variable i wird auf 0 gesetzt.
Der Rumpf wird ausgeführt, so lange i kleiner 10 ist.
Nach der Ausführung des Rumpfes wird i jedes Mal um eins erhöht.

while-Schleife

Die while-Schleife verwendet das Keyword while.

while (condition) {
    // Code...
}

Solange die Bedingung zutrifft, wird der Rumpf ausgeführt.

boolean isRunning = true;
while (isRunning) {
    // Code...
}

Jede while-Schleife kann auch als for-Schleife geschrieben werden und umgekehrt.

        int i = 0;
        while (10 > i) {
            System.out.println(i);
            i++;
        }
    

        for (int i = 0; 10 > i; i++) {
            System.out.println(i);
        }
    

do-while-Schleife

Die do-while-Schleife funktioniert im Grund genauso wie die while-Schleife. Der einzige Unterschied besteht darin, dass die Bedingung nach dem Schleifenrumpf überprüft wird. D.h. der Schleifenrumpf wird immer mindestens einmal ausgeführt. Die Schleife verwendet die Keywords do und while.

do {
    // Code...
} while (condition);

boolean isRunning = true;
do {
    // Code...
} while (isRunning);

for-each-Schleife

Die for-each oder auch enhanced-for-Schleife ist eine verkürzte Schreibweise der for-Schleife. Diese kann nur verwendet werden, wenn über Collections oder Arrays iteriert werden soll.

for (type identifier : array) {
    // Code...
}

int[] array = {4, 6, 2, 7, 1};

for (int i : array) {
    System.out.println(i);
}

Die Schleifenvariable i nimmt nacheinander alle Werte des Arrays an.

`break` & `continue`

Das Keyword break steht für die Zuständigkeit, eine Schleife an einem bestimmten Punkt vorzeitig zu beenden. Das Keyword continue steht für die Zuständigkeit, den weiteren Schleifenablauf zu überspringen und mit dem nächsten Schleifendurchlauf fortzufahren.

Die folgende Schleife gibt alle Zahlen von 0 bis 4 auf der Konsole aus, bis i die Zahl 5 enthält. Dann wird die komplette Schleife durch die break-Anweisung abgebrochen.

for (int i = 0; i < 10; i++) {
    if (i == 5) break;
    System.out.println(i);
}

Die folgende Schleife gibt alle Zahlen von 0 bis 4 auf der Konsole aus, bis i die Zahl 5 enthält. Dann wird die Ausgabe übersprungen und mit dem nächsten Schleifendurchlauf fortgesetzt.

for (int i = 0; i < 10; i++) {
    if (i == 5) continue;
    System.out.println(i);
}

Geschachtelte Schleifen

Wie Verzweigungen können auch Schleifen verschachtelt werden. Folgendes Beispiel gibt das kleine 1x1 in tabellarischer Form auf der Konsole aus.

for (int i = 1; i <= 10; i++) {
    for (int j = 1; j <= 10; j++) {
        System.out.print(i * j + "\t");
    }
    System.out.println();
}

2	3	4	5	6	7	8	9	10	
4	6	8	10	12	14	16	18	20	
6	9	12	15	18	21	24	27	30	
8	12	16	20	24	28	32	36	40	
10	15	20	25	30	35	40	45	50	
12	18	24	30	36	42	48	54	60	
14	21	28	35	42	49	56	63	70	
16	24	32	40	48	56	64	72	80	
18	27	36	45	54	63	72	81	90	
20	30	40	50	60	70	80	90	100	

break label

Es kann vorkommen, dass mit mehreren geschachtelten Schleifen gearbeitet wird. Das Keyword break beendet immer nur die innerste Schleife. Soll der Ablauf der äußeren Schleife abgebrochen werden, kann dafür ein gelabeltes break verwendet werden.

label:
for (int i = 1; i <= 10; i++) {
    for (int j = 1; j <= 10; j++) {
        System.out.print(i * j + "\t");
        if (i * j >= 50) {
            break label;
        }
    }
    System.out.println();
}

Ergibt das erste Ergebnis beim kleinen 1x1 eine Zahl die größer oder gleich 50 ist, wird das label gebrochen und die äußerste Schleife bricht ab. Dadurch wird in diesem Fall nur die erste Hälfte des kleinen 1x1 ausgegeben. label ist hier ein Identifier und kann auch anders benannt werden.

Übung

Erweitert den Taschenrechner um eine Schleife. Das Programm soll nach jedem Ergebnis nach einer weiteren Berechnung fragen.

            public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);  
                boolean isRunning = true;
                while (isRunning) {}
                    System.out.print("1st number: ");  
                    int x = sc.nextInt();  
                    System.out.print("2nd number: ");  
                    int y = sc.nextInt();  
                    System.out.print("""
                        =================
                        1: Addition
                        2: Subtraction
                        3: Multiplication
                        4: Division
                        =================
                        Option:\s""");
                    int option = sc.nextInt();
                    switch (option) {
                        case 1 -> System.out.println(x + " + " + y + " = " + (x + y));
                        case 2 -> System.out.println(x + " - " + y + " = " + (x - y));
                        case 3 -> System.out.println(x + " * " + y + " = " + (x * y));
                        case 4 -> System.out.println(x + " / " + y + " = " + (x / y));
                        default -> System.out.println("This option doesn't exist.");
                    } 
                    System.out.println("Should another calculation be performed?");
                    String keepGoing = sc.next();
                    if (!keepGoing.equalsIgnoreCase("y")) {  
                        isRunning = false;  
                    }
                } 
                System.out.println("Bye.");
                sc.close();
            }
        

Last modified: 19 August 2024