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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- mit
while,do-whileundforwiederholen - die passende Schleife für eine Aufgabe wählen
- Schleifen verschachteln
- Schleifen mit
breakundcontinuesteuern - eine Endlosschleife erkennen und stoppen
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!"); }
}54321Start!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:
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(); }
}Zahl (0 = Ende): 5Zahl (0 = Ende): 12Zahl (0 = Ende): -3Zahl (0 = Ende): 0Summe: 14do-while
Abschnitt betitelt „do-while“Manchmal soll der Block mindestens einmal laufen – etwa bei einer Eingabe, die so lange wiederholt wird, bis sie gültig ist:
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(); }
}Zahl zwischen 1 und 10: 15Zahl zwischen 1 und 10: 0Zahl zwischen 1 und 10: 7Danke, 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:
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); }
}Durchlauf 1Durchlauf 2Durchlauf 3Durchlauf 4Durchlauf 5Summe 1 bis 100: 5050Die 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.
Verschachtelte Schleifen
Abschnitt betitelt „Verschachtelte Schleifen“Eine Schleife darf in einer anderen stehen. Die innere läuft dann bei jedem Durchlauf der äußeren komplett durch:
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(); } }
} 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 100break und continue
Abschnitt betitelt „break und continue“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(); }
}1 2 4 5 7continuebricht nur den aktuellen Durchlauf ab und macht mit dem nächsten weiter – hier werden 3 und 6 übersprungen.breakverlä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.
Endlosschleifen
Abschnitt betitelt „Endlosschleifen“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.
Welche Schleife wann?
Abschnitt betitelt „Welche Schleife wann?“| 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“ |
Übungen
Abschnitt betitelt „Übungen“-
Gib alle geraden Zahlen von 2 bis 50 aus – einmal mit
forund%, 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();}} -
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();}} -
Berechne die Quersumme einer beliebig langen Zahl.
Lösung
% 10liefert die letzte Ziffer,/ 10schneidet 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();}} -
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();}} -
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();}} -
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();}} -
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 100Lösung
do-whilepasst 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();}} -
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();}}