Zum Inhalt springen

Schleifen

Mit Schleifen wiederholt ein Programm Anweisungen – so lange, bis eine Bedingung nicht mehr erfüllt ist. Zusammen mit Verzweigungen hast du damit alles beisammen, um echte kleine Algorithmen zu schreiben.

  • mit while, do-while und for wiederholen
  • die passende Schleife für eine Aufgabe wählen
  • Schleifen verschachteln
  • Schleifen mit break und continue steuern
  • eine Endlosschleife erkennen und stoppen
Countdown.java
package de.drv;
public class Countdown {
public static void main(String[] args) {
int zahl = 5;
while (zahl > 0) {
System.out.println(zahl);
zahl--;
}
System.out.println("Start!");
}
}
Terminal-Fenster
5
4
3
2
1
Start!

Die while-Schleife prüft vor jedem Durchlauf die Bedingung. Ist sie wahr, wird der Block ausgeführt – danach wird erneut geprüft. Ist sie falsch, geht es nach der Schleife weiter. Ist sie schon zu Beginn falsch, wird der Block kein einziges Mal ausgeführt.

Damit die Schleife endet, muss sich im Block etwas ändern, das die Bedingung irgendwann falsch macht – hier zahl--.

while passt gut, wenn vorher nicht feststeht, wie oft wiederholt wird – zum Beispiel, solange der Benutzer Zahlen eingibt:

Summieren.java
package de.drv;
import java.util.Scanner;
public class Summieren {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int summe = 0;
System.out.print("Zahl (0 = Ende): ");
int zahl = scanner.nextInt();
while (zahl != 0) {
summe += zahl;
System.out.print("Zahl (0 = Ende): ");
zahl = scanner.nextInt();
}
System.out.println("Summe: " + summe);
scanner.close();
}
}
Terminal-Fenster
Zahl (0 = Ende): 5
Zahl (0 = Ende): 12
Zahl (0 = Ende): -3
Zahl (0 = Ende): 0
Summe: 14

Manchmal soll der Block mindestens einmal laufen – etwa bei einer Eingabe, die so lange wiederholt wird, bis sie gültig ist:

Eingabe.java
package de.drv;
import java.util.Scanner;
public class Eingabe {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int zahl;
do {
System.out.print("Zahl zwischen 1 und 10: ");
zahl = scanner.nextInt();
} while (zahl < 1 || zahl > 10);
System.out.println("Danke, " + zahl + " ist gültig.");
scanner.close();
}
}
Terminal-Fenster
Zahl zwischen 1 und 10: 15
Zahl zwischen 1 und 10: 0
Zahl zwischen 1 und 10: 7
Danke, 7 ist gültig.

Die Bedingung steht am Ende – geprüft wird erst nach dem Durchlauf. Achte auf das Semikolon nach while (…).

Die Variable zahl ist vor der Schleife deklariert: Sie wird in der Bedingung gebraucht, und die steht außerhalb des Blocks.

Steht die Anzahl der Durchläufe fest, ist for die übliche Wahl. Sie fasst alles, was zum Zählen gehört, in einer Zeile zusammen:

Zaehlen.java
package de.drv;
public class Zaehlen {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println("Durchlauf " + i);
}
int summe = 0;
for (int i = 1; i <= 100; i++) {
summe += i;
}
System.out.println("Summe 1 bis 100: " + summe);
}
}
Terminal-Fenster
Durchlauf 1
Durchlauf 2
Durchlauf 3
Durchlauf 4
Durchlauf 5
Summe 1 bis 100: 5050

Die Klammer nach for hat drei Teile, getrennt durch Semikolons:

Teil Beispiel wann
Start int i = 1 einmal vor der Schleife
Bedingung i <= 5 vor jedem Durchlauf
Schritt i++ nach jedem Durchlauf

Jede for-Schleife lässt sich auch als while schreiben – for ist nur kompakter und zeigt auf einen Blick, wie gezählt wird.

Eine Schleife darf in einer anderen stehen. Die innere läuft dann bei jedem Durchlauf der äußeren komplett durch:

Einmaleins.java
package de.drv;
public class Einmaleins {
public static void main(String[] args) {
for (int zeile = 1; zeile <= 10; zeile++) {
for (int spalte = 1; spalte <= 10; spalte++) {
System.out.printf("%4d", zeile * spalte);
}
System.out.println();
}
}
}
Terminal-Fenster
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
Abbrechen.java
package de.drv;
public class Abbrechen {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
continue;
}
if (i > 7) {
break;
}
System.out.print(i + " ");
}
System.out.println();
}
}
Terminal-Fenster
1 2 4 5 7
  • continue bricht nur den aktuellen Durchlauf ab und macht mit dem nächsten weiter – hier werden 3 und 6 übersprungen.
  • break verlässt die ganze Schleife sofort – bei 8 ist Schluss.

Beide wirken nur auf die innerste Schleife. Setze sie sparsam ein: Eine Schleife, deren Ende man an der Bedingung ablesen kann, ist leichter zu verstehen.

Wird die Bedingung nie falsch, läuft die Schleife ewig:

int i = 0;
while (i < 10) {
System.out.println(i);
// i++ vergessen!
}

Auch ein Semikolon an der falschen Stelle reicht:

while (i < 10); {
i++;
}

Das Semikolon ist der (leere) Schleifenkörper – der Block danach gehört nicht mehr dazu.

Gewollt ist eine Endlosschleife manchmal trotzdem – mit while (true) und einem break an der Stelle, an der das Programm aufhören soll.

Schleife passt, wenn …
for die Anzahl der Durchläufe feststeht – „für jede Zahl von 1 bis 10“
while wiederholt wird, solange etwas gilt – „solange noch Eingaben kommen“
do-while der Block mindestens einmal laufen muss – „frage, bis die Eingabe stimmt“
  1. Gib alle geraden Zahlen von 2 bis 50 aus – einmal mit for und %, einmal ohne %.

    Lösung
    GeradeZahlen.java
    package de.drv;
    public class GeradeZahlen {
    public static void main(String[] args) {
    for (int i = 1; i <= 50; i++) {
    if (i % 2 == 0) {
    System.out.print(i + " ");
    }
    }
    System.out.println();
    for (int i = 2; i <= 50; i += 2) {
    System.out.print(i + " ");
    }
    System.out.println();
    }
    }
  2. Berechne die Fakultät einer eingelesenen Zahl: 5! = 1 · 2 · 3 · 4 · 5 = 120. Verwende long. Ab welcher Zahl stimmt das Ergebnis nicht mehr – und warum?

    Lösung

    20! = 2.432.902.008.176.640.000 passt gerade noch in einen long. Ab 21! läuft der Wertebereich über, und das Ergebnis wird negativ.

    Fakultaet.java
    package de.drv;
    import java.util.Scanner;
    public class Fakultaet {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("n: ");
    int n = scanner.nextInt();
    long fakultaet = 1;
    for (int i = 2; i <= n; i++) {
    fakultaet *= i;
    }
    System.out.println(n + "! = " + fakultaet);
    scanner.close();
    }
    }
  3. Berechne die Quersumme einer beliebig langen Zahl.

    Lösung

    % 10 liefert die letzte Ziffer, / 10 schneidet sie ab. Das wiederholt man, bis nichts mehr übrig ist.

    QuersummeBeliebig.java
    package de.drv;
    import java.util.Scanner;
    public class QuersummeBeliebig {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Zahl: ");
    long zahl = Math.abs(scanner.nextLong());
    int summe = 0;
    while (zahl > 0) {
    summe += zahl % 10;
    zahl /= 10;
    }
    System.out.println("Quersumme: " + summe);
    scanner.close();
    }
    }
  4. Berechne den größten gemeinsamen Teiler (ggT) zweier eingelesener Zahlen nach Euklid: Solange b nicht 0 ist, ersetze a durch b und b durch den Rest von a geteilt durch b. Dann ist a der ggT.

    Lösung

    Zum Testen: ggT(48, 18) = 6, ggT(17, 5) = 1.

    Ggt.java
    package de.drv;
    import java.util.Scanner;
    public class Ggt {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Erste Zahl: ");
    int a = scanner.nextInt();
    System.out.print("Zweite Zahl: ");
    int b = scanner.nextInt();
    int x = a;
    int y = b;
    while (y != 0) {
    int rest = x % y;
    x = y;
    y = rest;
    }
    System.out.println("ggT(" + a + ", " + b + ") = " + x);
    scanner.close();
    }
    }
  5. Lies eine Zahl ein und prüfe, ob sie eine Primzahl ist – also nur durch 1 und sich selbst teilbar.

    Lösung

    Es genügt, Teiler bis zur Wurzel der Zahl zu prüfen (teiler * teiler <= zahl): Hat eine Zahl einen größeren Teiler, hat sie auch einen kleineren. Zahlen unter 2 sind keine Primzahlen.

    Primzahl.java
    package de.drv;
    import java.util.Scanner;
    public class Primzahl {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.print("Zahl: ");
    int zahl = scanner.nextInt();
    boolean istPrim = zahl >= 2;
    for (int teiler = 2; teiler * teiler <= zahl; teiler++) {
    if (zahl % teiler == 0) {
    istPrim = false;
    break;
    }
    }
    if (istPrim) {
    System.out.println(zahl + " ist eine Primzahl.");
    } else {
    System.out.println(zahl + " ist keine Primzahl.");
    }
    scanner.close();
    }
    }
  6. Gib alle Primzahlen bis 100 aus.

    Lösung

    Die Prüfung aus Aufgabe 5 steckt in einer äußeren Schleife über alle Zahlen.

    PrimzahlenBis100.java
    package de.drv;
    public class PrimzahlenBis100 {
    public static void main(String[] args) {
    for (int zahl = 2; zahl <= 100; zahl++) {
    boolean istPrim = true;
    for (int teiler = 2; teiler * teiler <= zahl; teiler++) {
    if (zahl % teiler == 0) {
    istPrim = false;
    break;
    }
    }
    if (istPrim) {
    System.out.print(zahl + " ");
    }
    }
    System.out.println();
    }
    }
  7. Zahlenraten: Das Programm denkt sich eine Zahl zwischen 1 und 100 aus. Der Benutzer rät, das Programm antwortet „zu groß“ oder „zu klein“, bis die Zahl gefunden ist. Am Ende wird die Anzahl der Versuche ausgegeben.

    Eine Zufallszahl bekommst du so:

    import java.util.Random;
    // …
    int geheim = new Random().nextInt(1, 101); // 1 bis 100
    Lösung

    do-while passt hier gut: Geraten wird mindestens einmal.

    Zahlenraten.java
    package de.drv;
    import java.util.Random;
    import java.util.Scanner;
    public class Zahlenraten {
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int geheim = new Random().nextInt(1, 101);
    int versuche = 0;
    int tipp;
    System.out.println("Ich denke mir eine Zahl zwischen 1 und 100.");
    do {
    System.out.print("Dein Tipp: ");
    tipp = scanner.nextInt();
    versuche++;
    if (tipp > geheim) {
    System.out.println("zu groß");
    } else if (tipp < geheim) {
    System.out.println("zu klein");
    }
    } while (tipp != geheim);
    System.out.println("Richtig! Du hast " + versuche + " Versuche gebraucht.");
    scanner.close();
    }
    }
  8. Gib die ersten 20 Fibonacci-Zahlen aus: 1, 1, 2, 3, 5, 8, … – jede Zahl ist die Summe der beiden vorherigen.

    Lösung
    Fibonacci.java
    package de.drv;
    public class Fibonacci {
    public static void main(String[] args) {
    int a = 1;
    int b = 1;
    for (int i = 1; i <= 20; i++) {
    System.out.print(a + " ");
    int naechste = a + b;
    a = b;
    b = naechste;
    }
    System.out.println();
    }
    }