Bedingungen und Schleifen in Java

Eine Bedingung hat den Typ boolean: Sie liefert true oder false. Java benötigt dieses ausdrückliche Ergebnis in einer if- oder Schleifenbedingung. Eine ganze Zahl allein ist keine Bedingung, daher lässt sich while (count) nicht kompilieren; count > 0 stellt eine eindeutige Frage, die wahr oder falsch sein kann.

Zahlen und Zeichen vergleichen

Bei int a = 7; und int b = 10; sind a < b und a != b gleich true, während a >= b gleich false ist. Verschiedene Zahlentypen können verglichen werden: 3 == 3.0 ist true, nachdem Java die ganze Zahl erweiternd in einen double-Wert umgewandelt hat.

Bei einem char-Vergleich werden Unicode-Codenummern verwendet. Zum Beispiel ist 'a' < 'b' gleich true. Das gilt auch für 'Z' < 'a': Die Codes sind 90 und 97. Alle ASCII-Großbuchstaben von A bis Z stehen in dieser Ordnung vor den Kleinbuchstaben von a bis z.

Eine nützliche Antwort speichern

int age = 17;
boolean isAdult = age >= 18;
System.out.println(isAdult);

Der Vergleich ergibt false. Dieser Wert wird in isAdult gespeichert und anschließend ausgegeben. Ein aussagekräftiger Name erlaubt es, später im Code direkt if (isAdult) zu schreiben.

Halte Zuweisung und Vergleich auseinander. = speichert einen Wert; == vergleicht Werte. Bei einer ganzen Zahl schlägt if (x = 5) fehl, weil die Zuweisung eine ganze Zahl liefert. Bei einem booleschen Wert wird if (done = true) kompiliert, setzt done auf true und führt den Zweig aus. Um das vorhandene Flag zu prüfen, schreibe if (done).

Text und berechnete Dezimalzahlen vergleichen

Verwende command.equals("quit"), um die Zeichen eines Strings zu vergleichen. Der als „quit“ eingegebene Text stimmt überein, „Quit“ nicht. Verwende equalsIgnoreCase, wenn Groß- und Kleinschreibung keine Rolle spielen sollen, und !command.equals("quit"), um auf unterschiedlichen Text zu prüfen. Der Operator == prüft, ob Strings auf dasselbe Objekt verweisen, und ist daher für den Inhaltsvergleich von Benutzereingaben ungeeignet.

Binäre Gleitkommazahlen können viele Dezimalbrüche nicht exakt speichern. 0.1 + 0.2 ergibt 0.30000000000000004, daher ist 0.1 + 0.2 == 0.3 gleich false. Ein Vergleich mit Toleranz prüft, wie weit die berechneten Werte auseinanderliegen:

double sum = 0.1 + 0.2;
boolean closeEnough = Math.abs(sum - 0.3) < 1e-9;

Hier sorgt Math.abs dafür, dass die Differenz nicht negativ ist; die winzige Differenz liegt unter 1e-9, daher ist closeEnough gleich true. Wähle eine Toleranz, die zur benötigten Genauigkeit der Berechnung passt. Bei exakten Vergleichen von int-Werten tritt das Problem der Gleitkommarundung nicht auf.

Teilbarkeit und Bereiche prüfen

n % 3 == 0 prüft, ob eine ganze Zahl durch 3 teilbar ist. Verwende für ungerade Zahlen n % 2 != 0: Der Test schließt negative ungerade Werte ein, da -7 % 2 gleich -1 ist.

Schreibe jede Seite einer Bereichsprüfung einzeln: 0 < x && x < 10. Java kann 0 < x < 10 nicht als mathematische Verkettung lesen: Der erste Vergleich liefert bereits einen booleschen Wert, der nicht mit 10 verglichen werden kann.

Logische Operatoren verknüpfen vollständige Bedingungen, die wahr oder falsch sind. Lies eine verknüpfte Bedingung als Regel über die Daten und teste dann Werte, die sie erfüllen sollten, und Werte, die sie nicht erfüllen sollten.

Prüfungen verknüpfen und negieren

&& bedeutet und: Beide Teile müssen wahr sein. || bedeutet oder: Mindestens ein Teil muss wahr sein, auch wenn beide wahr sind. ! bedeutet nicht und kehrt einen booleschen Wert um.

| p | q | p && q | p || q | | --- | --- | --- | --- | | true | true | true | true | | true | false | false | true | | false | true | false | true | | false | false | false | false |

Eine angenehme Temperatur von 18 bis einschließlich 24 °C braucht beide Schranken: temp >= 18 && temp <= 24. Außerhalb dieses Intervalls bedeutet temp < 18 || temp > 24. Verknüpfst du die Schranken für den inneren Bereich mit ||, wird jede Zahl akzeptiert: Unter 18 ist die Prüfung der oberen Schranke wahr, und über 24 ist die Prüfung der unteren Schranke wahr.

Jeder Operand muss ein boolescher Ausdruck sein. Schreibe x == 1 || x == 2, denn x == 1 || 2 setzt eine ganze Zahl an eine Stelle, an der ein boolescher Wert erforderlich ist. Bei einer ganzen Zahl ist !x > 5 ungültig; !(x > 5) negiert den gesamten Vergleich.

Nur das Nötige auswerten

Java wertet && und || von links nach rechts aus und verwendet Kurzschlussauswertung, wenn der linke Teil das Ergebnis festlegt. Bei && überspringt eine falsche linke Seite die rechte Seite. Bei || überspringt eine wahre linke Seite die rechte Seite.

int total = 36;
int count = 0;
boolean largeAverage = count != 0 && total / count > 10;

Der erste Vergleich ist falsch, daher wird die Division übersprungen und largeAverage wird zu false. Vertauschst du die Operanden, findet die Division vor der Schutzbedingung statt; die Ganzzahldivision durch null wirft eine ArithmeticException. Setze die Sicherheitsprüfung vor die Berechnung, die sie schützt.

Die Gruppierung sichtbar machen

Von der höchsten zur niedrigsten Rangfolge stehen die relevanten Operatoren so: !, Größenvergleiche (<, <=, >, >=), Gleichheitsvergleiche (==, !=), &&, dann ||. Daher wird a || b && c als a || (b && c) gruppiert. Ist a wahr und sind b und c falsch, ist dieser Ausdruck wahr; (a || b) && c ist falsch. Klammern zeigen, welche Regel du meinst.

De Morgansche Gesetze übertragen eine Negation über eine verknüpfte Bedingung:

• !(p && q) entspricht !p || !q.
• !(p || q) entspricht !p && !q.

Negiere jeden Teil und vertausche den verknüpfenden Operator. Auf den Temperaturbereich angewendet, entspricht !(temp >= 18 && temp <= 24) dem Ausdruck temp < 18 || temp > 24.

Eine Regel mit Ausnahme ausdrücken

Ein gregorianisches Schaltjahr ist durch 4 teilbar, mit der Ausnahme, dass ein Jahrhundertjahr durch 400 teilbar sein muss:

boolean leap = (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;

Der erste Teil akzeptiert 2024. Er weist 1900 zurück, weil 1900 ein Jahrhundertjahr ist; die abschließende Prüfung akzeptiert 2000, weil es durch 400 teilbar ist. Das Jahr 2026 erfüllt keinen der beiden Teile.

Benannte boolesche Werte machen längere Prüfungen lesbarer, etwa isWeekend || isHoliday. Für zwei boolesche Werte ist ^ das exklusive Oder: Genau ein Operand muss wahr sein, wie bei !=. Die einzelnen Operatoren & und | berechnen ebenfalls das boolesche Und beziehungsweise Oder, werten aber beide Operanden aus; verwende && und || für Bedingungen mit Kurzschlussauswertung.

Ein if führt einen Block aus, wenn seine Bedingung wahr ist. Ein if mit einem else wählt genau einen von zwei Blöcken aus. Nachdem der gewählte Block beendet ist, wird die Ausführung mit der folgenden Anweisung fortgesetzt.

Einen Pfad wählen

int age = 16;
if (age >= 18) {
    System.out.println("Adult ticket");
} else {
    System.out.println("Youth ticket");
}
System.out.println("Next customer");

Die Bedingung ist falsch, daher lautet die Ausgabe „Youth ticket“, gefolgt von „Next customer“. Die letzte Anweisung gehört zu keinem der beiden Zweige. Setze die boolesche Bedingung in runde Klammern und die Anweisungen jedes Zweigs in geschweifte Klammern.

Ohne geschweifte Klammern gehört nur die nächste Anweisung zu einem if. Die Einrückung fasst Code nicht zusammen. In diesem fehlerhaften Beispiel erscheint die zweite Meldung bei jeder Punktzahl:

if (score < 50)
    System.out.println("Not passed");
    System.out.println("Try again");

Geschweifte Klammern um beide Ausgabeanweisungen machen beide von der Bedingung abhängig. Ein anderer Fehler ist ein Semikolon unmittelbar nach der Bedingung: if (x > 10); hat einen leeren Rumpf. Ein darauf folgender Block wird unabhängig ausgeführt, und ein else nach diesem unabhängigen Block hat kein zugehöriges if.

Ein Ergebnis verfügbar halten

Eine innerhalb eines Blocks deklarierte Variable ist nur innerhalb dieses Blocks sichtbar. Deklariere ein Ergebnis vor den Zweigen, wenn späterer Code es benötigt:

String ticket;
if (age >= 18) {
    ticket = "Adult ticket";
} else {
    ticket = "Youth ticket";
}
System.out.println(ticket);

Beide möglichen Pfade weisen ticket einen Wert zu, daher ist die anschließende Ausgabe zulässig. Würde nur der Zweig für den wahren Fall einen Wert zuweisen, würde Java den späteren Lesezugriff ablehnen: Die Variable wäre möglicherweise nicht initialisiert. Würde ticket in jedem Zweig separat deklariert, wäre nach der Entscheidung ebenfalls kein ticket verfügbar.

Eine Entscheidung in eine andere setzen

Ein verschachteltes if führt seine Prüfung nur aus, wenn die Ausführung den umgebenden Zweig erreicht:

if (hasTicket) {
    if (age < 12) {
        System.out.println("Child seat");
    } else {
        System.out.println("Standard seat");
    }
} else {
    System.out.println("Buy a ticket first");
}

Wer kein Ticket hat, erreicht das äußere else; die Altersprüfung wird übersprungen. Schützen beide verschachtelten Prüfungen lediglich dieselbe Aktion und hat keine von ihnen ein else, lassen sie sich zu if (hasTicket && age < 12) zusammenfassen.

Die Regel zum Dangling-Else-Problem ordnet ein else dem nächsten noch nicht zugeordneten if zu. Ohne geschweifte Klammern ändert eine optische Ausrichtung an einem äußeren if nichts an dieser Regel. Folgt auf eine äußere Prüfung, ob x positiv ist, eine innere Prüfung, ob y positiv ist, gehört das nächste else zur Prüfung von y. Soll das else zur äußeren Prüfung gehören, sind geschweifte Klammern um die vollständige innere Entscheidung nötig.

Mit ?: einen Wert wählen

Der bedingte Operator wählt einen von zwei Werten:

int n = 7;
String label = n % 2 == 0 ? "even" : "odd";

Die Bedingung ist falsch, daher liefert der Ausdruck „odd“. Seine Form ist condition ? valueIfTrue : valueIfFalse. Verwende ihn für eine kurze Wertauswahl; verwende ein if, wenn Zweige mehrere Aktionen ausführen. Verschachtelte bedingte Ausdrücke machen den gewählten Pfad schnell schwer nachvollziehbar.

Eine else if-Kette prüft Bedingungen der Reihe nach und wählt die erste wahre Bedingung aus. Sobald dieser Zweig ausgeführt wird, werden die übrigen Bedingungen übersprungen. Ein abschließendes else behandelt die verbleibenden Werte; ohne dieses kann die Kette ohne Aktion bleiben.

Überlappende Schwellenwerte ordnen

Prüfe bei Punktzahlen von 0 bis 100 zuerst die höchste Note:

String grade;
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else if (score >= 60) {
    grade = "D";
} else {
    grade = "F";
}

Bei 85 schlägt die erste Prüfung fehl und die zweite ist erfolgreich. Das Programm weist „B“ zu, ohne die übrigen Schwellenwerte zu prüfen. Wird score >= 80 erreicht, bedeutet das bereits, dass die Punktzahl unter 90 liegt, sodass eine zusätzliche obere Schranke unnötig ist.

Stünde score >= 60 zuerst, würde jede zum Bestehen ausreichende Punktzahl „D“ erhalten. Gehe vom strengsten zutreffenden Fall zu den allgemeineren über. Diese Reihenfolge ist wichtig, weil mehrere Bedingungen wahr sein können, obwohl nur ein Zweig ausgeführt wird.

Den kombinierten Fall zuerst behandeln

FizzBuzz hat einen Sonderfall, in dem sich zwei Regeln überlappen: Vielfache von 3 und 5 brauchen „FizzBuzz“. Prüfe diesen Fall vor jeder einzelnen Teilbarkeitsprüfung:

if (n % 15 == 0) {
    System.out.println("FizzBuzz");
} else if (n % 3 == 0) {
    System.out.println("Fizz");
} else if (n % 5 == 0) {
    System.out.println("Buzz");
} else {
    System.out.println(n);
}

Die Prüfung % 15 == 0 akzeptiert 30; 9 erreicht „Fizz“, 10 erreicht „Buzz“ und 7 erreicht den letzten Zweig. Würde % 3 == 0 zuerst geprüft, würde 30 zu früh akzeptiert und nur „Fizz“ ausgegeben.

Ein Ergebnis oder mehrere Aktionen wählen

Getrennte if-Anweisungen sind unabhängige Entscheidungen. Bei x = 15 kann ein if (x > 10) „big“ ausgeben und ein folgendes if (x > 0) außerdem „positive“. Verbindest du sie mit else if, wird die zweite Prüfung nicht erreicht, wenn die erste wahr ist. Verwende unabhängige Prüfungen, wenn beide Aktionen nötig sein können; verwende eine Kette für ein ausgewähltes Ergebnis.

Randwerte und ungültige Werte prüfen

Eine Kette für ganzzahlige Temperaturen mit temp < 10, dann temp > 10 && temp < 25 und dann temp >= 25 erfasst genau 10 nicht. Ersetze die zweite Prüfung durch temp < 25: Wird sie erreicht, ist die erste Prüfung bereits fehlgeschlagen, der Wert ist also mindestens 10. Ein abschließendes else behandelt dann 25 und mehr.

Probiere für jeden Schwellenwert den Wert unmittelbar darunter, den Schwellenwert selbst und den Wert unmittelbar darüber. Bei der Notenkette zeigen 89, 90 und 91, ob die Grenze für A korrekt eingeschlossen ist. Teste auch die äußeren Grenzen.

Validiere eine Punktzahl, bevor du eine Note vergibst: Setze score < 0 || score > 100 an den Anfang und gib dort „Invalid score“ aus. Die späteren Zweige verarbeiten dann nur gültige Punktzahlen; 150 kann nicht versehentlich „A“ erhalten. Die Validierung ist ein eigener erster Fall, keine Korrektur, nachdem die Note bereits gewählt wurde.

Ein switch wählt einen Fall, indem es einen Wert mit festen Marken vergleicht. Das passt zu benannten Befehlen und nummerierten Auswahlmöglichkeiten. Verwende eine else if-Kette, wenn die Auswahl von einem Bereich oder mehreren Variablen abhängt.

Exakte Werte abgleichen

Ein wertbasierter switch akzeptiert Selektoren vom Typ char, byte, short, int, deren Wrappertypen, String und Aufzählungstypen. Ohne Vorschaufunktionen werden Selektoren vom Typ long, float, double und boolean nicht unterstützt. Marken müssen Konstanten sein: Eine Bedingung wie score >= 90 ist keine Wertmarke.

switch (day) {
    case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
    case 6, 7 -> System.out.println("Weekend");
    default -> System.out.println("Invalid day");
}

Ein Fall mit Pfeil führt nur seinen eigenen Code aus, ohne Fall-through. Kommas gruppieren mehrere Marken für eine Aktion. Der Tag 6 gibt „Weekend“ aus; der Tag 9 entspricht keinem aufgeführten Wert und gibt „Invalid day“ aus.

String-Marken gleichen Inhalte exakt und unter Beachtung der Groß- und Kleinschreibung ab. Der Befehl „Start“ passt nicht zu case "start". Eine doppelte Marke ist ein Kompilierfehler, und ein switch kann Fälle mit Pfeil und Fälle mit Doppelpunkt nicht mischen.

Einen Wert erzeugen

Ein switch-Ausdruck berechnet ein Ergebnis:

int days = switch (month) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    case 2 -> 28;
    default -> 0;
};

In einem Jahr ohne Schalttag ergibt Monat 9 den Wert 30, Monat 2 den Wert 28 und der ungültige Monat 13 den Wert 0. Das Semikolon nach der schließenden Klammer beendet die Variablendeklaration.

Ein Ausdruck muss vollständig sein: Jeder mögliche Selektorwert muss ein Ergebnis haben. Füge für diese Beispiele mit int und String ein default ein. Eine wertbasierte switch-Anweisung kann default auslassen; bei einem Wert ohne passenden Fall wird dann kein Fall ausgeführt. Ein Ausdruck, der einen Wert liefert, kann die Erzeugung seines Ergebnisses nicht einfach überspringen.

Einem Block mit yield ein Ergebnis geben

Ein Fall, der vor der Auswahl seines Werts etwas berechnet, braucht einen Block:

int days = switch (month) {
    case 2 -> {
        boolean leap = (year % 4 == 0 && year % 100 != 0)
                || year % 400 == 0;
        yield leap ? 29 : 28;
    }
    case 4, 6, 9, 11 -> 30;
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    default -> 0;
};

yield liefert den Wert des Falls an den switch-Ausdruck. Der Februar ergibt 29 im Jahr 2024 und 28 im Jahr 2026. Ein einzelner Ausdruck nach einem Pfeil wie case 2 -> 28; braucht kein yield.

Die ältere Doppelpunktform lesen

switch (level) {
    case 1:
        System.out.println("Bronze");
    case 2:
        System.out.println("Silver");
        break;
    case 3:
        System.out.println("Gold");
        break;
}

Bei Stufe 1 tritt die Ausführung in den ersten Fall ein und läuft in den zweiten weiter, sodass sowohl „Bronze“ als auch „Silver“ ausgegeben werden. Das ist Fall-through: Eine Marke mit Doppelpunkt beendet die Ausführung nicht. break beendet den switch. Aufeinanderfolgende Marken mit Doppelpunkt können sich absichtlich eine Aktion teilen; ein fehlendes break nach einer Aktion kann versehentlich die nächste ausführen.

Ein switch mit char kann 'a', 'e', 'i', 'o', 'u' zum Ergebnis „vowel“ gruppieren, während default „other“ ergibt. Dasselbe Prinzip der exakten Werte gilt für Zeichen, Befehle und numerische Auswahlmöglichkeiten.

Eine while-Schleife prüft ihre Bedingung vor jedem Durchlauf. Ist die Bedingung wahr, führt Java den Rumpf aus und kehrt zur Prüfung zurück. Ist sie falsch, wird die Ausführung nach der Schleife fortgesetzt. Eine falsche erste Prüfung bedeutet null Durchläufe.

Start, Prüfung, Rumpf und Aktualisierung verfolgen

int i = 1;
while (i <= 5) {
    System.out.println(i);
    i++;
}

Der Startwert ist 1. Jeder Durchlauf gibt den aktuellen Wert aus und erhöht ihn dann. Der fünfte Durchlauf gibt 5 aus und ändert i zu 6. Die nächste Prüfung ist falsch, daher endet die Schleife. Der Rumpf wird fünfmal ausgeführt, die Bedingung aber sechsmal geprüft: einmal vor jedem Durchlauf und ein letztes Mal mit falschem Ergebnis.

Eine Zählschleife braucht einen Startwert, eine Prüfung und eine Aktualisierung, die zum Abbruch führt. Lässt du i++ weg, gibt diese Schleife unendlich oft 1 aus. Ein versehentliches Semikolon ist eine weitere Falle: In while (i <= 5); ist die leere Anweisung der Rumpf. Beginnt i innerhalb des Bereichs, wird der spätere Block nie erreicht und kann den Wert nicht aktualisieren.

Beim Überschreiten eines Grenzwerts anhalten

Eine Gleichheitsprüfung ist als Abbruchprüfung oft unzuverlässig. Beginnend bei 0 und jeweils um 3 erhöht, werden 0, 3, 6, 9, 12 und so weiter erreicht. Die Prüfung i != 10 kann das Überschreiten von 10 nicht erkennen, weil 10 übersprungen wird. Die Prüfung i < 10 beendet die Schleife nach der Verarbeitung von 9. Wähle eine Schranke, die zur Richtung der Aktualisierung passt.

Einige Schleifen wiederholen sich unbekannt oft. Zum Beispiel:

int amount = 1;
int days = 0;
while (amount < 1000) {
    amount *= 2;
    days++;
}

Jeder Durchlauf verdoppelt die Menge und zählt einen Tag. Nach neun Durchläufen beträgt sie 512; nach zehn beträgt sie 1024. Die falsche Prüfung bei 1024 beendet die Schleife mit days gleich 10. Eine Schleife kann oberhalb ihres Schwellenwerts enden, wenn die Aktualisierung in größeren Schritten erfolgt.

Vor der Entscheidung über den Abbruch einlesen

while (true) {
    String line = scanner.nextLine();
    if (line.equals("stop")) {
        break;
    }
    System.out.println("You wrote: " + line);
}

Hier ist scanner der Scanner für die Eingabe. Die Schleife liest eine Zeile ein, prüft auf „stop“ und gibt nur gewöhnliche Zeilen wieder aus. Der Stoppbefehl wird eingelesen, aber nicht verarbeitet. while (true) braucht einen erreichbaren Abbruch, um zu enden; eine Schleife, die sich ohne Abbruch weiter wiederholt, ist eine Endlosschleife.

Zustandsänderungen protokollieren

Betrachte ein Produkt:

int n = 3;
int product = 1;
while (n > 0) {
    product *= n;
    n--;
}

Die Multiplikation verwendet den alten Wert von n, und das Dekrement folgt danach. Würdest du das Dekrement vor die Multiplikation setzen, würden andere Werte multipliziert.

Deklariere ein laufendes Ergebnis vor der Schleife, damit es von einem Durchlauf zum nächsten erhalten bleibt. Eine im Rumpf deklarierte Variable wird jedes Mal neu erstellt, wenn die Ausführung ihre Deklaration erreicht. Gib innerhalb des Rumpfs aus, um Zwischenergebnisse zu sehen; gib nach der schließenden Klammer aus, um das Endergebnis einmal anzuzeigen.

Eine do-while-Schleife führt den Rumpf aus, bevor sie prüft, ob ein weiterer Durchlauf nötig ist. Verwende sie, wenn die erste Aktion stattfinden muss, etwa das Anzeigen eines Menüs oder das Abfragen eines Eingabewerts.

Nach der ersten Aktion prüfen

int i = 10;
do {
    System.out.println(i);
    i++;
} while (i < 5);

Der Rumpf gibt 10 aus und erhöht i auf 11. Erst dann prüft Java i < 5. Die Bedingung ist falsch, daher gibt es keinen zweiten Durchlauf. Eine bei 10 beginnende while (i < 5)-Schleife würde nichts ausgeben.

Das Semikolon nach dem abschließenden while (...) ist erforderlich. Es schließt die do-while-Anweisung ab. Das unterscheidet sich vom versehentlichen Semikolon nach dem Kopf einer kopfgesteuerten while-Schleife, das einen leeren Schleifenrumpf erzeugt.

Wiederholen, solange die Eingabe ungültig ist

int rating;
do {
    System.out.print("Rating (1-5): ");
    rating = Integer.valueOf(scanner.nextLine());
} while (rating < 1 || rating > 5);

Die Eingabeaufforderung erscheint vor der ersten Prüfung, sodass der Benutzer den zu prüfenden Wert eingeben kann. Bei den Eingaben 7, dann 0 und dann 4 sind die ersten beiden Bedingungen wahr und lösen eine erneute Eingabeaufforderung aus. Die letzte Bedingung ist falsch, daher endet die Schleife mit rating gleich 4.

Die Bedingung beschreibt das Fortsetzen, nicht das Akzeptieren. Eine gültige Bewertung erfüllt rating >= 1 && rating <= 5. Die Schleife wiederholt sich, solange diese Aussage falsch ist; nach den De Morganschen Gesetzen lässt sich das als rating < 1 || rating > 5 schreiben. Eine Und-Verknüpfung zwischen diesen äußeren Schranken wäre nie wahr: Eine Zahl kann nicht gleichzeitig unter 1 und über 5 liegen.

Die geprüfte Variable vor dem Block deklarieren

Die schließende Klammer beendet den Gültigkeitsbereich des Rumpfs, bevor die Bedingung ausgewertet wird. Eine Deklaration wie int rating innerhalb des do-Blocks wäre daher in der abschließenden Bedingung nicht verfügbar. Deklariere die Variable vor do und weise ihr die Eingabe innerhalb des Rumpfs zu. Die Zuweisung wird immer vor der ersten Prüfung ausgeführt.

Dieselbe Platzierung ist wichtig, wenn der akzeptierte Wert danach verwendet wird. rating bleibt nach der gesamten Schleife im Gültigkeitsbereich und enthält nun den zuletzt eingelesenen Wert.

Ein Menü offen halten

String choice;
do {
    System.out.println("a: show status, q: quit");
    choice = scanner.nextLine();
    if (choice.equals("a")) {
        System.out.println("Ready");
    }
} while (!choice.equals("q"));

Jeder Durchlauf zeigt das Menü an und liest eine Auswahl ein. Die Eingabe „a“ gibt „Ready“ aus und wiederholt die Schleife. Die Eingabe „q“ überspringt die Aktion und beendet die Schleife an der Bedingung. Auch bei einem unbekannten Befehl wird wiederholt, weil er nicht „q“ ist.

Enthält der Rumpf kein auf die Schleife zielendes continue, lässt sich eine do-while-Schleife als while (true) mit einem break bei negierter Bedingung am Ende umschreiben. Bei einer solchen Umschreibung braucht ein continue besondere Aufmerksamkeit: In der ursprünglichen do-while-Schleife springt es zur Bedingung, während es in einer while-true-Schleife zum Anfang springt und die hinzugefügte Prüfung am Ende überspringen kann.

Eine for-Schleife fasst die Steuerung einer Zählaufgabe in einem Kopf zusammen. Sie ist nützlich, wenn du den Bereich oder die Anzahl der Durchläufe vor Beginn der Wiederholung kennst.

Den Kopf in Ausführungsreihenfolge lesen

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

Die Initialisierung wird einmal ausgeführt und setzt i auf 1. Java prüft i <= 5, führt bei wahrem Ergebnis den Rumpf aus, führt i++ aus und kehrt zur Prüfung zurück. Die Aktualisierung steht im Kopf, wird aber nach dem Rumpf ausgeführt. Die abschließende falsche Prüfung beendet die Schleife.

Beim gewöhnlichen Zählen haben i++ und ++i an der Stelle der Aktualisierung dieselbe Wirkung, weil der Wert keines der beiden Ausdrücke verwendet wird. Halte die Änderungen des Zählers im Kopf, damit die Folge leicht vorherzusagen ist.

Den ersten und letzten Wert wählen

Bei Aufwärtsschritten um jeweils eins und einem Endwert, der mindestens so groß wie der Startwert ist, ergibt ein ausgeschlossener Endwert die Anzahl Endwert minus Startwert; ein eingeschlossener Endwert fügt einen Durchlauf hinzu. Bei größeren Schritten musst du die tatsächlich erreichten Werte auflisten oder zählen. Eine abwärts zählende Schleife muss in der passenden Richtung prüfen: Ein Start bei 10 mit i <= 1 ergibt null Durchläufe.

Ein Off-by-one-Fehler schließt einen Endwert unerwünscht ein oder aus. Um 1 bis 10 auszugeben, lässt i < 10 die 10 aus; verwende i <= 10. Prüfe den ersten und letzten Wert im Rumpf sowie den ersten Wert, der die Bedingung nicht erfüllt.

Ein Ergebnis über einen Bereich aufbauen

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

Der Rumpf addiert jede ganze Zahl einmal und endet bei 5050. Ein Produkt beginnt anders: Initialisiere product mit 1, bevor du mit den Zahlen 1 bis 5 multiplizierst. Das ergibt 120; ein Start bei 0 würde das Produkt nach jeder Multiplikation bei 0 belassen.

Auf Gültigkeitsbereiche und leere Rümpfe achten

Ein im Kopf deklarierter Zähler existiert während der gesamten Schleife, aber nicht nach ihrer schließenden Klammer. Deklariere ihn früher, wenn späterer Code seinen letzten Wert benötigt.

Ein Semikolon unmittelbar nach dem Kopf ist ein leerer Rumpf. In for (int i = 0; i < 3; i++); wird die leere Anweisung dreimal ausgeführt. Ein folgender Block, der „Hello“ ausgibt, wird einmal nach der Schleife ausgeführt, nicht dreimal. Geschweifte Klammern gehören direkt hinter den Kopf.

Jeder Teil des Kopfs kann ausgelassen werden. for (;;) { ... } hat keine Abbruchbedingung und verhält sich wie while (true); die Schleife braucht einen Abbruch wie break, um zu enden.

Die übersichtlichste Schleife auswählen

Die Formen können dieselbe Wiederholung ausdrücken, aber beim Umschreiben muss die Reihenfolge von Prüfungen und Aktualisierungen erhalten bleiben, einschließlich dessen, was ein continue überspringt.

Ein vorzeitiger Abbruch kann eine Wiederholung beenden, sobald ihre Aufgabe erfüllt ist. Ein übersprungener Durchlauf kann unerwünschte Arbeit auslassen und die Schleife weiterlaufen lassen. Verfolge genau, wohin der Ablauf jeweils springt: break und continue haben unterschiedliche Aufgaben.

Eine Suche mit break beenden

for (int n = 51; n <= 100; n++) {
    if (n % 7 == 0) {
        System.out.println(n);
        break;
    }
}

Die Werte 51 bis 55 bestehen die Teilbarkeitsprüfung nicht. Der nächste Wert, 56, wird ausgegeben und break verlässt die Schleife sofort. Die Aktualisierung wird nach diesem break nicht ausgeführt. Ohne den Abbruch würden auch spätere Vielfache wie 63 und 70 ausgegeben.

Ein break ohne Sprungmarke bezieht sich auf die nächste umgebende Schleife oder den nächsten umgebenden switch. Die Ausführung wird nach diesem Konstrukt fortgesetzt; das gesamte Programm wird dadurch nicht beendet.

Mit continue überspringen

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

Für 3, 6 und 9 überspringt continue die Ausgabeanweisung. In einer for-Schleife wird die Aktualisierung im Kopf trotzdem ausgeführt, gefolgt von der Bedingung. Die Ausgabe enthält 1, 2, 4, 5, 7, 8 und 10.

Bei einer while- oder do-while-Schleife springt continue zur Bedingung. Jede darunter im Rumpf stehende Aktualisierung wird übersprungen. Beginnt ein while-Zähler bei 0 und ist die erste Aktion if (i % 3 == 0) { continue; }, wird ein späteres i++ im Rumpf nie erreicht. Der Zähler bleibt bei 0 und die Schleife wiederholt sich unendlich. Setze die nötige Aktualisierung vor jeden Pfad, auf dem sie übersprungen wird, oder verwende einen for-Kopf, damit die Aktualisierung automatisch erfolgt.

Verschachtelte Schleifen gezielt verlassen

Ein gewöhnliches break innerhalb einer inneren Schleife beendet nur diese innere Schleife. Eine Sprungmarke kann eine äußere Schleife als Abbruchziel benennen:

outer:
for (int a = 1; a <= 10; a++) {
    for (int b = 1; b <= 10; b++) {
        if (a * b == 24 && a + b == 10) {
            System.out.println("Found " + a + " and " + b);
            break outer;
        }
    }
}

Die Suche durchläuft die Paare der Reihe nach. Bei a = 4 und b = 6 sind beide Prüfungen erfüllt und das break mit Sprungmarke verlässt beide Schleifen. continue outer würde stattdessen zur Aktualisierung der äußeren Schleife und dann zu ihrer nächsten Prüfung übergehen.

switch-Abbrüche von Schleifenabbrüchen unterscheiden

In einer Menüschleife mit einem switch in Doppelpunktform beendet break innerhalb eines Falls den switch. Es beendet nicht von selbst die umgebende Schleife. Ein übersichtliches Muster setzt im Fall für das Beenden ein Schleifen-Flag auf false und verlässt dann den switch mit break. Die Schleife endet, wenn die nächste Prüfung ihrer Bedingung das falsche Flag erkennt. Fälle mit Pfeil brauchen kein break, um Fall-through zu verhindern.

break ohne Sprungmarke ist innerhalb einer Schleife oder eines switch zulässig; continue ist innerhalb einer Schleife zulässig. An anderer Stelle verhindern sie das Kompilieren. Belasse die normale Abbruchregel in der Schleifenbedingung, wenn sie dorthin passt. Verwende while (true) mit einem break, wenn die Abbruchprüfung sinnvollerweise nach dem Einlesen der Eingabe, aber vor ihrer Verarbeitung steht. Mehrere Abbrüche können nützlich sein, aber jeder zusätzliche Pfad bringt beim Nachvollziehen weiteren zu verfolgenden Zustand mit sich.

Ein Zähler hält fest, wie viele Werte eine Bedingung erfüllen. Ein Akkumulator verbindet Werte zu einem laufenden Ergebnis. Deklariere beide vor der Schleife, damit jeder Durchlauf auf dem bisherigen Ergebnis aufbaut.

Passend zur Operation initialisieren

Verwende int count = 0; und erhöhe den Zähler, wenn ein Element die Bedingung erfüllt. Eine Summe beginnt bei 0; aktualisiere sie mit sum += value;. Ein Produkt beginnt bei 1, weil beim Multiplizieren eines anfänglichen Werts von 0 jeder spätere Faktor zunichtegemacht würde. Wird eine Summe im Rumpf initialisiert, setzt sie sich bei jedem Durchlauf zurück.

Bei einem Zahlenbereich kann die Schrittweite der Schleife die Werte auswählen: Addierst du die geraden ganzen Zahlen von 2 bis 100 in Schritten von 2, ergibt das 2550. Oder setze eine Bedingung in die Schleife. Zählst du die Zahlen von 1 bis 100, die durch 3 oder durch 5 teilbar sind, ergibt das 47: Die sechs Vielfachen von 15 dürfen nur einmal gezählt werden.

Die Eingabe vor dem Addieren beenden

Eine Endemarkierung ist ein besonderer Eingabewert, der das Einlesen beendet. Sie ist kein gewöhnlicher Datenwert:

int sum = 0;
int count = 0;
while (true) {
    int number = Integer.valueOf(scanner.nextLine());
    if (number == 0) {
        break;
    }
    sum += number;
    count++;
}

Bei der Eingabe 12, 7, 5, 0 nimmt die Summe nacheinander die Werte 12, 19 und 24 an. Der Zähler erreicht 3. Die letzte 0 löst den Abbruch aus, bevor eine der beiden Variablen geändert wird. Würde sie mitgezählt, entstünde ein viertes Element und der Mittelwert wäre falsch, obwohl das Addieren von null die Summe unverändert lässt.

Erst nach Prüfung der Anzahl dividieren

if (count > 0) {
    double average = (double) sum / count;
    System.out.println(average);
} else {
    System.out.println("No numbers entered");
}

Das Beispiel gibt 8.0 aus. Bei ganzzahligen Operanden verwirft die Division den Nachkommateil: 25 / 4 ist 6. Wandle vor der Division um, um 6,25 zu erhalten: (double) sum / count. Eine anschließende explizite Typumwandlung, (double) (sum / count), wandelt lediglich das bereits abgeschnittene Ergebnis in 6,0 um.

Kommt die Endemarkierung zuerst, ist die Anzahl 0. Eine Ganzzahldivision durch null wirft eine ArithmeticException; eine Gleitkommasumme von null dividiert durch null ergibt NaN. Die Prüfung der Anzahl verhindert, dass eine leere Eingabe einen nicht aussagekräftigen Mittelwert erzeugt.

Mehrere Ergebnisse in einem Durchlauf verfolgen

Für die Punktzahlen 55, 72, 90, 48 und 81 ergeben sich bei einer Bestehensgrenze von 60 fünf Punktzahlen und drei bestandene Fälle. Führe einen Gesamtzähler für jede Punktzahl und einen Zähler für bestandene Fälle innerhalb der Bestehensbedingung. 100.0 * passed / total ergibt 60,0 Prozent; 100.0 bewirkt, dass mit Gleitkommazahlen gerechnet wird. Prüfe auch vor dieser Division, ob die Gesamtzahl positiv ist.

Wo die Ausgabe steht, verändert das angezeigte Ergebnis. Strecken von 5, 3 und 8 km ergeben die laufenden Summen 5, 8 und 16 km, wenn sie innerhalb der Schleife nach der Addition ausgegeben werden. Die Ausgabe danach zeigt nur die endgültigen 16 km.

Einen ausreichend großen Typ für die Summe wählen

Das Maximum eines int ist 2.147.483.647. Die Summe aller ganzen Zahlen von 1 bis 100.000 sollte 5.000.050.000 ergeben, aber ein int springt ohne Fehlermeldung auf 705.082.704. long sum = 0; speichert diese Summe korrekt; das Maximum von long beträgt etwa 9,2 × 10¹⁸. Eine nachträgliche erweiternde Typumwandlung eines bereits übergelaufenen Ergebnisses kann den verlorenen Wert nicht wiederherstellen.

Einige Schleifen merken sich einen besten Wert, andere, ob ein Treffer vorgekommen ist. Wähle den Anfangszustand so, dass er vor und nach jedem Durchlauf zutrifft.

Den bisher besten Wert festhalten

Um ein Maximum zu verfolgen, ersetze es nur, wenn der aktuelle Wert größer ist: if (value > max) { max = value; }. Beginnend mit dem ersten Messwert ergeben die Temperaturen 14, 19, 11, 23 und 17 °C nacheinander die Maxima 14, 19, 19, 23 und 23 °C. Für ein Minimum wird stattdessen < verwendet.

Ein Maximum bei 0 beginnen zu lassen, schlägt bei ausschließlich negativen Daten fehl: -5, -2 und -9 würden fälschlich 0 als Ergebnis hinterlassen. Initialisiere mit einem tatsächlichen Messwert oder beginne bei Integer.MIN_VALUE für ein int-Maximum und bei Integer.MAX_VALUE für ein int-Minimum. Gib an, dass kein Ergebnis vorliegt, wenn es keine Messwerte gab.

Um eine Position festzuhalten, aktualisiere sie im selben Zweig wie den Wert. Ein striktes > behält bei gleichen Werten das erste Maximum; >= ersetzt es erneut und behält das letzte.

Nach einem Treffer anhalten

int n = 1;
while (n * n <= 500) {
    n++;
}

Bei 22 ist das Quadrat 484, also wird ein weiterer Durchlauf ausgeführt. Bei 23 ist es 529 und die Bedingung ist nicht erfüllt. Die Schleife hat die kleinste positive ganze Zahl gefunden, deren Quadrat größer als 500 ist. Eine Suche in einem begrenzten Bereich kann stattdessen jeden Kandidaten in einer for-Schleife prüfen und beim ersten Treffer abbrechen.

Beginne für eine Frage nach mindestens einem Treffer mit einem falschen Flag und setze es bei einem Treffer auf wahr. Beginne für eine Frage nach allen Werten mit wahr und setze das Flag bei einem Gegenbeispiel auf falsch. Setze keines der beiden Flags bei späteren Werten in einem else-Zweig zurück: Ein späterer nicht passender Wert löscht beispielsweise einen zuvor gefundenen negativen Messwert nicht aus.

Auf einen Teiler prüfen

Eine Primzahl ist mindestens 2 und hat keinen Teiler von 2 bis zur um eins kleineren Zahl. Bei einer kleinen positiven ganzen Zahl prüft eine kürzere Prüfung Teiler nur bis zur Quadratwurzel:

int n = 91;
boolean isPrime = n >= 2;
for (int d = 2; d * d <= n; d++) {
    if (n % d == 0) {
        isPrime = false;
        break;
    }
}

Die beiden Faktoren eines Paars können nicht beide größer als die Quadratwurzel sein. Bei 91 ergibt der Teiler 7 einen Rest von null und setzt das Flag auf falsch. Bei 97 ist keine Zahl von 2 bis 9 ein Teiler, daher bleibt das Flag wahr. Werte unter 2 beginnen mit einem falschen Flag. Verwende für große positive int-Werte d <= n / d, um einen Überlauf bei d * d zu vermeiden.

Pro Durchlauf eine Dezimalziffer entfernen

Bei einer nicht negativen ganzen Zahl extrahiert % 10 die letzte Ziffer und die Ganzzahldivision / 10 entfernt sie:

int n = 4072;
int sum = 0;
while (n > 0) {
    sum += n % 10;
    n /= 10;
}

Die Ziffern sind 2, 7, 0 und 4 und ergeben 13. Der Arbeitswert n endet bei 0. Um Ziffern umzukehren, aktualisiere reversed = reversed * 10 + n % 10;, bevor du die Ziffer entfernst; aus 1234 wird 4321, wenn das Ergebnis in den gewählten Typ passt.

Beim Zählen der Ziffern braucht null einen Durchlauf, obwohl n > 0 von Anfang an falsch ist. Verwende eine do-while-Schleife, die den Zähler erhöht und n durch 10 dividiert. Sie zählt für 0 eine Ziffer und für positive Werte die übliche Anzahl.

Verschachtelte Schleifen wiederholen für jeden äußeren Durchlauf eine vollständige Wiederholung. Sie sind nützlich für Zeilen, Spalten, Tabellen und Formen. Die innere Schleife muss jedes Mal neu beginnen, wenn die äußere Schleife sie erreicht.

Eine Zeile ausgeben und dann beenden

for (int row = 1; row <= 3; row++) {
    for (int col = 1; col <= 5; col++) {
        System.out.print(row * col + "\t");
    }
    System.out.println();
}

Die erste Zeile enthält 1, 2, 3, 4, 5; die zweite enthält 2, 4, 6, 8, 10; die dritte enthält 3, 6, 9, 12, 15. Die innere Ausgabe erzeugt Spalten in einer Zeile; das println nach der inneren Schleife beendet diese Zeile. Würde println in die innere Schleife verschoben, stünde jedes Produkt in einer eigenen Zeile.

Bei festgelegten Anzahlen multipliziere die äußeren mit den inneren Durchläufen. Drei äußere und vier innere Durchläufe führen den inneren Rumpf 12-mal aus. Die Tabelle oben enthält drei mal fünf, also 15, Produktausgaben.

Die Zeilenlänge ändern lassen

for (int row = 1; row <= 4; row++) {
    for (int col = 1; col <= row; col++) {
        System.out.print("*");
    }
    System.out.println();
}

Die innere Schleifengrenze hängt nun von der Zeile ab. Die Anzahlen sind 1, 2, 3 und 4, das Dreieck enthält also 10 Sterne. Eine einzelne Multiplikation mit fester Anzahl wäre falsch, weil die innere Schleife nicht in jeder Zeile gleich oft läuft.

Verwende unterschiedliche Namen für Schleifenzähler mit überlappenden Gültigkeitsbereichen. Ein weiteres int i innerhalb einer Schleife zu deklarieren, in der i bereits im Gültigkeitsbereich liegt, lässt sich nicht kompilieren. Initialisiere bei einer inneren while-Schleife ihren Zähler zu Beginn jedes äußeren Durchlaufs. Wird er nur vor der äußeren Schleife initialisiert, bleibt er nach der ersten Zeile jenseits der Schleifengrenze.

Werte an einem einheitlichen Zeitpunkt verfolgen

Bei einer Schleife von 1 bis 4 subtrahiere ungerade Werte von einer bei 0 beginnenden Summe und addiere gerade Werte:

Halte fest, ob eine Zeile den Anfang oder das Ende eines Durchlaufs beschreibt. Berücksichtige bei der Prüfung des Abbruchs die letzte nicht erfüllte Bedingung. Eine Ablaufverfolgung, die Werte vor und nach der Aktualisierung mischt, kann eine korrekte Schleife falsch aussehen lassen.

Trennzeichen zwischen Elemente setzen

Fünf Zahlen brauchen vier Kommas. Gib vor jedem Element außer dem ersten ein Trennzeichen aus:

for (int i = 1; i <= 5; i++) {
    if (i > 1) {
        System.out.print(", ");
    }
    System.out.print(i);
}

Die Ausgabe lautet „1, 2, 3, 4, 5“, ohne Komma am Anfang oder Ende. Das ist ein Zaunpfahlproblem: Die Anzahl der Zwischenräume unterscheidet sich von der Anzahl der Elemente.

Testfälle, die Fehler aufdecken

Probiere null Durchläufe, einen Durchlauf und die Werte an und neben jeder Grenze. Probiere bei Eingabeschleifen zuerst die Endemarkierung. Prüfe bei verschachtelten Schleifen, ob die zweite Zeile korrekt zurückgesetzt wird. Vorübergehende Ausgaben der Schleifenvariablen zeigen den tatsächlichen Fortschritt. Hängt ein Programm, untersuche jeden Pfad auf eine Aktualisierung oder einen Abbruch und stoppe es im Terminal mit Strg+C oder mit der Stopptaste der Entwicklungsumgebung.