for-Schleifen

Sinn und Zweck von for-Schleifen

Schleifen werden immer dann verwendet, wenn man Anweisungen mehrfach ausführen will. Die for-Schleife eignet sich besonders gut für Fälle, in denen die Anzahl der Durchläufe im Voraus bekannt ist. Sie wird häufig zum Zählen, zum Durchlaufen von Zahlenreihen oder zum Bearbeiten von Daten in gleichmäßigen Schritten verwendet. Daher werden for-Schleifen manchmal auch als Zählschleifen bezeichnet.

Syntax / Grundstruktur

Syntaxdiagramm der for-Schleife und ein einfaches Beispiel
Autor: Ulrich Helmich 07/2025, Lizenz: Public domain

Schleifenkopf

Der sogenannte Schleifenkopf besteht aus dem Schlüsselwort for und drei wichtigen Komponenten, die in ein Paar runder Klammern eingefasst und durch Semikola getrennt sind.

Diese drei Komponenten sind:

1. Deklaration und Initialisierung der Laufvariablen

Beispiele: int i=5; int j=12; int monat = 1;

Merke: Die Laufvariable muss nicht immer i heißen, sie kann jeden sinnvollen Namen annehmen. Oft bezeichnet man die Laufvariable auch als Zählvariable.

Achtung: Die Laufvariable einer for-Schleife ist eine besondere lokale Variable. Ihr Gültigkeitsbereich erstreckt sich nur auf die for-Schleife. Außerhalb dieser Schleife existiert die Laufvariable nicht! Ein Versuch, nach Beendigung der for-Schleife auf die Laufvariable zuzugreifen, führt zu einem Fehler.

2. Abbruchbedingung

Dieser logische Ausdruck wird bei jedem Schleifendurchlauf erneut überprüft. Wenn das Ergebnis dieser Überprüfung true ist, wird ein weiterer Schleifendurchlauf gestartet. Wenn das Ergebnis aber false ist, wird die Schleife abgebrochen.

Beispiele: i <=12; j >= 0; monat <= 12;

3. Inkrementierung / Dekrementierung der Laufvariable

In diesem Teil der for-Schleife wird die Laufvariable verändert. Wenn sie um einen bestimmten - immer gleichen - Wert erhöht wird, spricht man von einer Inkrementierung.

Beispiele: i++; j = j+2; monat = monat+3;

Man kann die Laufvariable aber auch verringern, dann spricht man von einer Dekrementierung.

Beispiele: i--, j = j-2; monat = monat-3;

Die Anweisung

Eine Anweisung ist immer entweder eine einfache Anweisung. Dann sind keine geschweiften Klammern notwendig:

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

Eine Anweisung kann aber auch aus einem Anweisungsblock (kurz: Block) bestehen, der von geschweiften Klammern eingeschlossen ist:

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

Laufvariablen vom Typ int

Die meisten for-Schleifen besitzen eine Laufvariable vom Typ int. Da die Laufvariable auch als Zählvariable bezeichnet wird und man meistens mit ganzen Zahlen zählt, macht das auch Sinn.

Die Off-by-one-Errors

Bei der Implementierung von for-Schleifen mit int-Variablen als Zählvariablen macht man besonders gern einen Fehler, der in der Fachsprache als "Off-by-one-Error" bezeichnet wird. Meistens passiert dieser Fehler, wenn man in der Abbruchbedingung den Operator <= statt < verwendet.

Die folgende for-Schleife soll die Summe der Zahlen von 1 bis 10 berechnen:

public void berechneSumme()
{
    int summe = 0;

    for (int i = 1; i < 10; i++)
    {
        summe += i;
    }

    System.out.println("Summe: " + summe);
}

Die Schleife bricht bereits ab, wenn i den Wert 9 hat, also wird nicht 55 ausgegeben wie erwartet, sondern 45. Hätte man den Vergleichsoperator <= eingesetzt, würde der Quelltext ein richtiges Ergebnis liefern.

Auch bei dem Startwert der Laufvariable muss man gut aufpassen. Natürlich ist es ein Unterschied, ob man mit int i=0 oder int i=1 anfängt.

Besondere Vorsicht ist beim Umgang mit Arrays geboten, da das erste Arrayelement immer den Index 0 hat und das letzte Element eines Arrays aus n Elementen den Index n-1.

Laufvariablen vom Typ double

Betrachten Sie folgende for-Schleife:

for (double x = 0.0; x <= 1.0; x += 0.1)
   System.out.println("x = " + x);

Die Laufvariable einer for-Schleife muss keine ganze Zahl sein, auch Variablen vom Type double sind möglich. Eine solche Laufvariable kann dann auch um kleine Werte wie 0.1 inkrementiert oder dekrementiert werden.

Man muss nur etwas aufpassen, da es mit den double-Variablen leicht zu Rundungsfehlern kommen kann. Eine Schleifenbedingung wie x == 10.0 kann unter Umständen nie erreicht werden. Im vorherigen Durchgang hatte x vielleicht den Wert 9.900000001, nach Inkrementierung um 0.1 hat x dann den Wert 10.000000001. Damit wäre die Bedingung x == 10.0 aber nicht erfüllt, und die Schleife würde nicht abbrechen.

Workaround* für solche Probleme:

Man verwendet einen int-Schleifenzähler und berechnet dann erst in der Schleife den eigentlichen double-Wert:

for (int i = 0; i <= 10; i++)
{
   double x = i * 0.1;
   System.out.println("x = " + x);
}

Diese for-Schleife erzeugt ebenfalls 10 Durchgänge, und der double-Wert x hat in jedem Durchgang die gleichen Werte (0, 0.1, 0.2, ..., 1.0) wie in dem vorherigen Beispiel. Die Laufvariable ist aber vom Typ int, und daher kann bei der Überprüfung der Abbruchbedingung kein Rundungsfehler auftreten.

*Lustige Sache am Rande: Meine Dreamweaver-Rechtschreibkorrektur wollte das Wort Workaround durch Orkanwarnung ersetzen!

Mehrere Laufvariablen

Laufvariablen können nicht nur vom Typ double sein, sondern es ist sogar möglich, mehrere Laufvariablen in einer for-Schleife zu benutzen. Betrachten wir dazu folgendes Beispiel aus [4]:

for (int i=5, j=25;  j+i > 5;  i=i-2, j--)
   System.out.println(i+j);

Diese for-Schleife besitzt zwei Laufvariablen, die man hier vielleicht besser als Zählvariablen bezeichnet. Diese beiden Variablen müssen durch ein Komma getrennt werden.

In der Abbruchbedingung können beide Zählvariablen ausgewertet werden: j + i > 5.

Es ist auch möglich, beide Zählvariablen gleichzeitig zu inkrementieren oder zu dekrementieren: i = i-2, j-- . Auch hier dient wieder ein Komma zur Trennung der beiden Ausdrücke.

Kleiner Tipp: Ein guter Programmierstil ist etwas anderes. Die Lesbarkeit leidet und die Fehleranfälligkeit wird erhöht, wenn man mit mehreren Laufvariablen arbeitet.

Inkrementation/Dekrementation im Schleifenrumpf

Die Laufvariable kann auch im Schleifenrumpf erhöht oder erniedrigt werden:

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

Ob das sinnvoll ist, ist eine andere Frage, aber es ist technisch möglich. Man muss dann nur darauf achten, dass nach der Schleifenbedingung in der Klammer noch ein Semikolon kommt.

Break und Continue

Break

Manchmal möchte man die for-Schleife verlassen, auch wenn die Schleifenbedingung noch erfüllt ist, weil eine andere wichtige Situation eingetreten ist. Mit dem Befehl break kann man eine for-Schleife jederzeit verlassen.

for (int i=5, i < 25; i++)
{
   if (i == 13) break;
   System.out.println(i);
}

Auch dieses Beispiel ist nicht unbedingt sinnvoll, verdeutlicht aber den Gebrauch des break-Befehls. Hier ein vielleicht etwas besseres Beispiel:

for (int i=1; i<=100; i++)
{
   zufall = wuerfel.nextInt(1000)+1;
   if (zufall == 13)
   {
      System.out.println("Gewonnen!");
      break;
   }
   System.out.println(zufall + " ist nicht Deine Glückszahl!");
}

Continue

Das Gegenteil von break ist der Befehl continue. Dieser Befehl kann im Schleifenkörper eingesetzt werden, er bewirkt dann, dass alle Befehle, die auf continue folgen, übersprungen werden, so dass sofort der nächste Schleifendurchgang gestartet wird.

Break und Continue bei geschachtelten Schleifen

Dieses Beispiel habe ich dem Buch von Mikael Olsson ^[5] gefunden:

myLoop: for (int i = 0; i < 10; i++)
{
   for (int j = 0; j < 10; j++)
   {
      break myLoop; // end outer for loop
   }
}

Wenn zwei oder mehr for-Schleifen ineinander geschachtelt sind, bewirkt der break-Befehl normalerweise das sofortige Verlassen der Schleifenebene, in der er vorkommt. Im obigen Beispiel würde der break-Befehl also die innere for-Schleife beenden, aber die äußere würde weiter laufen.

Nun wurde die äußere for-Schleife aber mit einem sogenannten Label versehen (myLoop: ). Mit

break myLoop;

wird nun die äußere for-Schleife mit dem entsprechenden Label verlassen.

Dieses Verfahren funktioniert übrigens auch mit dem continue-Befehl. Mit

continue myLoop;

würde die innere for-Schleife verlassen und die äußere for-Schleife würde sofort den nächsten Schleifendurchgang starten.

Verschachtelte for-Schleifen

Betrachten Sie folgende for-Schleife:

   for (int a=1; a <= 10; a++)
	{
      for (int b=1; b <= 10; b++)
         System.out.print(a*b + ", ");
      System.out.println();
   }

Die "äußere" for-Schleife enthält im Schleifenkörper zwei Anweisungen, nämlich eine "innere" for-Schleife und einen System.out.println()-Befehl. Beide Anweisungen werden durch {} zu einem Anweisungsblock zusammengeschlossen.

Diese doppelte for-Schleife läuft folgendermaßen ab:

Zunächst wird die äußere Laufvariable a auf 1 gesetzt. Dann startet die innere Schleife mit b = 1. Ausgegeben wird dann 1 * 1 = 1. Als Tabelle kann man das Ganze etwas übersichtlicher gestalten:

Es wird also das kleine Einmaleins ausgegeben. Solch eine Schachtelung von for-Schleifen kommt sehr häufig in der Programmierung vor. Stellen Sie sich die Simulation eines Brettspiels wie Schach oder Dame vor. Das Spielbrett besteht aus 8 x 8 Feldern. Wenn Sie nun eine Methode schreiben wollen, die Ihnen die Position der weißen Dame zurückliefert, müssen Sie jedes Feld untersuchen.

Bei einer guten Umsetzung des Spiels müssten Sie die Dame natürlich nicht suchen, denn aus der Reihenfolge der Züge wüsste das System stets, auf welchem Feld sich die weiße Dame aufhält - aber das nur am Rande.

Dazu setzen Sie am besten eine doppelte for-Schleife ein, die ungefähr so aussehen könnte:

for (int x = 1; x <= 8; x++)
   for (int y = 1; y <= 8; y++)
	   if (getFigur(feld[x][y]) == DAME_W)
		{
		   xPos = x;
			yPos = y;
		}

Die Methode getFigur() liefert ihnen die Figur zurück, die auf dem jeweiligen Feld mit den Koordinaten (x,y) steht. DAME_W ist eine Konstante, die die weiße Dame repräsentieren soll, und feld[x][y] ist das gerade untersuchte Feld - ein Element eines zweidimensionalen Arrays.