2.7 Schleifen 

Schleifen dienen dazu, bestimmte Anweisungen immer wieder abzuarbeiten. Zu einer Schleife gehören die Schleifenbedingung und der Rumpf. Die Schleifenbedingung entscheidet darüber, unter welcher Bedingung die Wiederholung ausgeführt wird. Sie muss ein boolescher Ausdruck sein. In Abhängigkeit von der Schleifenbedingung kann der Rumpf mehrmals ausgeführt werden. Dazu wird bei jedem Schleifendurchgang die Schleifenbedingung geprüft. Das Ergebnis entscheidet, ob der Rumpf ein weiteres Mal durchlaufen (true) oder die Schleife beendet wird (false).

2.7.1 Die while-Schleife 

Die while-Schleife ist eine abweisende Schleife, da sie vor jedem Schleifeneintritt die Schleifenbedingung prüft:

while ( Ausdruck )

  Anweisung

Vor jedem Schleifendurchgang wird der Ausdruck neu ausgewertet und ist das Ergebnis true, so wird der Rumpf ausgeführt. Die Schleife ist beendet, wenn das Ergebnis false ist. Ist die Bedingung schon vor dem ersten Eintritt in den Rumpf nicht wahr, so wird der Rumpf erst gar nicht durchlaufen. Der Typ der Bedingung muss boolean sein.

Wird innerhalb des Schleifenkopfs schon alles Interessante erledigt, so muss trotzdem eine Anweisung folgen. Dies ist der passende Einsatz für die leere Anweisung. Etwa

while ( leseWeiterBisZumEnde() )
  ;                              // Rumpf ist leer

Die Methode leseWeiterBisZumEnde() gibt true zurück, falls noch Zeichen gelesen werden können. Wenn der Rückgabewert false ist, so wird die Schleife beendet.

Da der Typ wiederum boolean sein muss, sehen die Anweisungen in Java im Gegensatz zu C(++) etwas präziser aus:

while ( i != 0 ) {               // und nicht while ( i ) wie in C(++)
  ...
}

Endlosschleifen

Ist die Bedingung einer while-Schleife immer wahr, dann handelt es sich um eine Endlosschleife:

while ( true )
{
  // immer wieder und immer wieder
}

Aus dieser Endlosschleife lässt sich mittels break entkommen. (Aber auch eine Exception oder System.exit() würden die Schleife beenden.)

2.7.2 Schleifenbedingungen und Vergleiche mit == 

Eine Schleifenabbruchbedingung kann ganz unterschiedlich aussehen. Beim Zählen ist es häufig der Vergleich auf einen Endwert. Oft steckt an dieser Stelle ein absoluter Vergleich mit ==, der aus zwei Gründen problematisch werden kann.

Lange, lange durchhalten

int i = Wert;

while ( i != 9 )
  i++;

Ist der Wert der Variablen i kleiner als 9, so haben wir beim Zählen kein Problem, denn dann ist anschließend spätestens bei 9 Schluss. Ist der Wert allerdings echt größer als 9, so ist die Bedingung ebenso wahr und der Schleifenrumpf wird ziemlich lange durchlaufen. Genau genommen so weit, bis wir durch einen Überlauf¹  wieder bei 0 beginnen und dann auch bei 9 landen. Die Absicht ist sicherlich eine andere gewesen. Die Schleife sollte nur solange zählen wie i kleiner 9 ist und sonst nicht. Daher passt Folgendes besser:

int i = Wert;

while ( i < 9 )
  i++;

Jetzt rennt der Interpreter bei Zahlen größer 9 nicht endlos weiter, sondern stoppt die Schleife sofort.

Rechenungenauigkeiten

Das zweite Problem ergibt sich bei Gleitkommazahlen. Es ist sehr problematisch, echte Vergleiche zu fordern:

double d = 0.0;

 while ( d != 1.0 )
{
  d += 0.1;
  System.out.println( d );
}

Lassen wir das Programmsegment laufen, so sehen wir, dass die Schleife hurtig über das Ziel hinausschießt:

0.1 
0.2
0.30000000000000004
0.4
0.5
0.6
0.7
0.7999999999999999
0.8999999999999999
0.9999999999999999
1.0999999999999999
1.2
1.3

... bis das Auge müde wird ...

Bei Fließkommawerten bietet sich daher immer an, mit den relationalen Operatoren < oder > zu arbeiten.

Eine zweite Möglichkeit neben dem echten Kleiner/Größer-Vergleich ist, eine erlaubte Abweichung zu definieren. Mathematiker bezeichnen die Abweichung von zwei Werten mit dem griechischen Kleinbuchstaben Epsilon. Wenn wir einen Vergleich von zwei Fließkommazahlen anstreben und bei einem Gleichheitsvergleich die Abweichung mit betrachten wollen, so schreiben wir einfach:

if ( Math.abs(a – b) <= epsilon )
  ...

Epsilon ist die erlaubte Abweichung. Math.abs(x) berechnet von einer Zahl x den Absolutwert.

2.7.3 Die do/while-Schleife 

Dieser Schleifentyp ist eine annehmende Schleife, da die Schleifenbedingung erst nach jedem Schleifendurchgang geprüft wird. Bevor es zum ersten Test kommt, ist der Rumpf also schon einmal durchlaufen:

do
  Anweisung
while ( Ausdruck );                  // Bemerke das Semikolon

Es ist wichtig, auf das Semikolon hinter der while-Anweisung zu achten. Liefert die Bedingung ein true, so wird der Rumpf erneut ausgeführt. Andernfalls wird die Schleife beendet und das Programm wird mit der nächsten Anweisung nach der Schleife fortgesetzt.

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

Äquivalenz einer while- und einer do/while-Schleife

Die do-Schleife wird seltener gebraucht als die while-Schleife. Dennoch lassen sich beide ineinander überführen. Zunächst der erste Fall. Wir ersetzen eine while-Schleife durch eine do/while-Schleife:

while ( Ausdruck )
  Anweisung

Führen wir uns noch einmal vor Augen, was hier passiert. In Abhängigkeit vom Ausdruck wird der Rumpf ausgeführt. Da zunächst ein Test kommt, wäre die do/while-Schleife schon eine Blockausführung weiter. So fragen wir in einem ersten Schritt mit einer if-Anweisung ab, ob die Bedingung wahr ist oder nicht. Wenn ja, dann lassen wir den Programmcode in einer do/while-Schleife abarbeiten. Die äquivalente do/while-Schleife sieht also wie folgt aus:

if ( Ausdruck )
  do
    Anweisung
  while ( Ausdruck ) ;

Nun der zweite Fall. Wir ersetzen die do/while-Schleife durch eine while-Schleife:

do
  Anweisung
while ( Ausdruck ) ;

Da zunächst die Anweisungen ausgeführt werden und anschließend der Test, schreiben wir für die while-Variante die Ausdrücke einfach vor den Test. So ist sichergestellt, dass diese zumindest einmal abgearbeitet wurden:

Anweisung
while ( Ausdruck )
  Anweisung

2.7.4 Die for-Schleife 

Die for-Schleife ist eine spezielle Variante einer while-Schleife und wird typischerweise zum Zählen benutzt. Genauso wie while-Schleifen sind for-Schleifen abweisend, der Rumpf wird also erst dann ausgeführt, wenn die Bedingung wahr ist.

for ( int i = 1; i <= 10; i++ )
  System.out.println( i );

Eine genauere Betrachtung der Schleife zeigt die unterschiedlichen Segmente:

Initialisierung der Schleife Der erste Teil der for-Schleife ist ein Ausdruck wie i=1, der vor der Durchführung der Schleife genau einmal ausgeführt wird. Dann wird das Ergebnis verworfen. Tritt in der Auswertung ein Fehler auf, so wird die Abarbeitung unterbrochen und die Schleife kann nicht vollständig ausgeführt werden. Der erste Teil kann lokale Variablen definieren und initialisieren. Diese Zählvariable ist dann außerhalb des Blocks nicht mehr gültig.2  Es darf noch keine lokale Variable mit dem gleichen Namen geben.

Schleifentest/Schleifenbedingung Der mittlere Teil, wie i<=10, wird vor dem Durchlaufen des Schleifenrumpfs – also vor jedem Schleifeneintritt – getestet. Ergibt der Ausdruck false, wird die Schleife nicht durchlaufen und beendet. Das Ergebnis muss, wie bei einer while-Schleife, vom Typ boolean sein.

Schleifen-Inkrement durch einen Fortschaltausdruck Der letzte Teil, wie i++, wird immer am Ende jedes Schleifendurchlaufs, aber noch vor dem nächsten Schleifeneintritt ausgeführt. Das Ergebnis wird nicht weiter verwendet. Ergibt die Bedingung des Tests true, dann befindet sich beim nächsten Betreten des Rumpfs der veränderte Wert im Rumpf.

Betrachten wir das Beispiel, so ist die Auswertungsreihenfolge folgender Art:

Eine Endlosschleife

Da alle drei Ausdrücke im Kopf der Schleife optional sind, können sie weggelassen werden und es ergibt sich eine Endlosschleife. Die trennenden Semikolons dürfen nicht verschwinden:

for ( ; ; )
  ;

Falls demnach keine Schleifenbedingung angegeben ist, ist der Ausdruck immer wahr. Es folgt keine Initialisierung und keine Auswertung des Fortschaltausdrucks.

Wann for und wann while?

Da sich while- und for-Schleife sehr ähnlich sind, besteht die berechtigte Frage, wann die eine und wann die andere zu nutzen ist. Leider verführt die kompakte for-Schleife sehr schnell zu einer Überladung. Manche Programmierer packen gerne alles in den Schleifenkopf hinein und der Rumpf besteht nur aus einer leeren Anweisung. Dies ist ein schlechter Stil und muss vermieden werden. Die for-Schleife sollte dort eingesetzt werden, wo sich alle drei Ausdrücke im Schleifenkopf auf dieselbe Variable beziehen, etwa zum Durchzählen einer Variablen (Zählvariable oder Laufvariable):

// Zahlen von 1 bis 10 ausgeben

for ( int i = 1; i <= 10; i++ )
  System.out.println( i );

Vermieden werden sollten unzusammenhängende Ausdrücke im Schleifenkopf.

for-Schleifen und ihr Kommaoperator

Im ersten und letzen Teil einer for-Schleife lässt sich ein Komma einsetzen. Damit lassen sich entweder mehrere Variablen gleichen Typs deklarieren – wie wir es schon kennen – oder mehrere Ausdrücke nebeneinander schreiben.³ 

for ( int i=1, j=9; i <= j; i++, j-- )
  System.out.println( i + "*" + j + " = " + i*j );

1*9 = 9
2*8 = 16
3*7 = 21
4*6 = 24
5*5 = 25

int x, y;
for ( x=initX(), y=initY(), x++, y++;
      x==10 && y==10;
      x+=xinc(), y+=yinc() )
{
  // ...
}

Wird das Komma für die Deklaration mehrerer Variablen verwendet, so kann dahinter kein Ausdruck mit Komma abgetrennt werden. Wenn der Compiler mit einer Deklaration beginnt, könnte er gar nicht zwischen einer zweiten Deklaration für eine Variable und dem folgenden Ausdruck unterscheiden, da das Komma die Variablennamen abtrennt.

int i;
for ( int cnt=0, i=1; cnt < 10; cnt++ )
  ;

Der erste Teil leitet eine Anweisung ein. Nach dem Komma folgt für den Compiler aber die Deklaration einer zweiten Variablen. Da sie jedoch schon eine Zeile vorher definiert wurde, meldet der Compiler einen Fehler.

Auch umgekehrt funktioniert das nicht, denn eine Variablendeklaration ist kein Ausdruck, sie ist formal betrachtet eine Anweisung.

for ( i=0, int j=0; ; )
  ;

Im letzten Teil von for, dem Fortschaltausdruck, darf keine Variablendeklaration stehen. Wozu sollte das auch gut sein?

Zu den weiteren Einschränkungen gehört, dass es nicht möglich ist, Variablen unterschiedlicher Typen zu deklarieren, wie es etwa for ( int i=0, double d=0.0; ; ) zeigt. Hier muss eine Variable außerhalb der for-Schleife definiert werden. Das Deklarieren einer äußeren Variable bringt aber auch vielleicht den unerwünschten Effekt mit sich, dass eine Variable, die eigentlich nur in der Schleife gültig sein soll, eine zu große Sichtbarkeit bekommt. Dann lässt sich ein Block aufspannen, in dem dann nur eine Variable gültig ist.

{
  double d = 12;
  for ( int i = 0; i < 20; i++ )
    ;
}
// jetzt sind i und d wieder frei
double d = 12;

2.7.5 Ausbruch planen mit break und Wiedereinstieg mit continue 

Wird innerhalb einer for-, while- oder do/while-Schleife eine break-Anweisung eingesetzt, so wird der Schleifendurchlauf beendet.

int i = 10;

while ( true )
  if ( i-- == 0 )
    break;

Die Anweisung ist nützlich, um im Programmblock festzustellen, ob die Schleife noch einmal durchlaufen werden soll. Sie entlastet den Schleifenkopf, der sonst die Bedingung testen würde. Da ein kleines break jedoch im Programmtext verschwinden könnte, die Bedeutung aber groß ist, sollte ein kleiner Hinweis auf diese Anweisung gesetzt werden.

Innerhalb einer for-, while- oder do/while-Schleife lässt sich eine continue-Anweisung einsetzen, die nicht wie break die Schleife beendet, sondern zum Schleifenkopf zurückgeht, sodass dort eine neue Prüfung durchgeführt werden kann, ob die Schleife weiter durchlaufen werden soll. Ein häufiges Einsatzfeld sind Schleifen, die im Rumpf immer wieder Werte so lange holen und testen, bis sie passend zur Weiterverarbeitung sind.

for ( int i=0; i<=10; i++ )
{
  if ( i%2 == 1 )
    continue;



  System.out.println( i + " ist eine gerade Zahl" );

}

2.7.6 break und continue mit Sprungmarken 

Obwohl das Schlüsselwort goto in der Liste der reservierten Wörter auftaucht, ist diese Operation nicht erlaubt. Programmieren mit goto sollte vermieden werden. Mit dem Konzept von break lässt sich gut leben und es kann auch noch ruhigen Gewissens eingesetzt werden. Doch zum Schrecken vieler kann break noch schmutziger eingesetzt werden, nämlich mit einer Sprungmarke. Das bringt Java verdächtig nahe in die goto-Welt der unstrukturierten Programmiersprachen, was die Entwickler eigentlich vermeiden wollten. Da jedoch Abbruchbedingungen – der häufigste Einsatzort eines goto – vereinzelt auftreten, wurden in Java break und continue mit Sprungmarken eingeführt.

one:
  while ( condition )
  {
    ...

  two:
    while ( condition )

    {
    ...
    // break oder continue
    }
  // nach two
  }

Wird innerhalb der zweiten while-Schleife ein break platziert, dann würde es beim Aufruf die while-Schleife beenden. Das continue würde zur Fortführung der while-Schleife führen. Dieses Verhalten entspräche C, aber in Java ist es erlaubt, hinter den Schlüsselworten break und continue Sprungmarken zu setzen. Das C-Verhalten kann in Java mit break two oder continue two beschrieben werden. Dass aber auch beispielsweise break one möglich ist, zeigt die Mächtigkeit dieses Befehls. Durch break und continue mit Marken ist daher ein goto nahezu überflüssig.

¹   Es ist Integer.MAX_VALUE + Integer.MAX_VALUE + 2 wieder gleich 0. Die Schleife muss also »nur« 4.294.967.296-mal durchlaufen werden.

²   Im Gegensatz zu C++ ist das Verhalten klar definiert und kein hin und her. In C++ implementierten Compilerbauer die Variante einmal so, dass die Variable nur im Block gilt, andere interpretieren die Sprachspezifikation so, dass diese auch außerhalb gültig blieb. Die aktuelle C++-Definition schreibt nun vor, dass die Variable außerhalb des Blockes nicht mehr gültig ist. Da es jedoch noch alten Programmcode gibt, haben viele Compilerbauer eine Option eingebaut, mit der das Verhalten der lokalen Variablen bestimmt werden kann.

³   Wenn Java eine ausdruckorientierte Sprache wäre, dann könnten wir hier beliebige Programme hineinlegen.