Was ist eine for-Schleife?

Die Schleife verwendet üblicherweise eine sog. Zählvariable. Sie enthält meist einen numerischen Wert, der die Anzahl der zu wiederholenden Schleifendurchläufe durch sein Inkrement oder Dekrement steuert.

Ihre grundsätzliche Syntax gestaltet sich wie folgt: Nach dem Schlüsselwort for folgt ein Paar runder Klammern, in denen, durch Semikola getrennt

• die Deklaration und Initialisierung der Zählvariablen
• die Abbruchbedingung
• das Inkrement oder Dekrement der Zählvariablen

erfolgen. Nach dem letzten Ausdruck darf kein Semikolon stehen. Schlüsselwort und die geklammerten Ausdrücke werden zusammen als Schleifenkopf bezeichnet.
Innerhalb des dann folgenden, in geschweifte Klammern gefassten Schleifenkörpers, werden die auszuführenden Anweisungen notiert.

public class ForClass {
    
    public void gibAus(){
        for(int i=0;i<10;i++){
            System.out.println(i);
        }
    }
    
    public static void main(String[] args){
        ForClass fc = new ForClass();
        fc.gibAus();
    }
}

Erreicht der Ausführungsstrang des Programms die Schleife, gestaltet sich der weitere Ablauf wie folgt:
Zunächst wird die Zählvariable erzeugt (int i=0;) und anschließend innerhalb der Abbruchbedingung (i<10;) überprüft. Ergibt diese true, wird der Schleifenkörper betreten, und die darin notierten Ausdrücke werden der Reihe nach ausgeführt. Ergibt sich bei der Prüfung false, wird die Schleife verlassen und das Programm nach der Schleife fortgesetzt.
Nach Abarbeiten des Schleifenkörpers wird der dritte im Kopf notierte Ausdruck (i++) verarbeitet: der Wert der Zählvariablen wird entsprechend modifiziert und im Anschluss erneut innerhalb der Abbruchbedingung überprüft. Wird hier wiederum true ausgegeben wird der Schleifenkörper wieder betreten, abgearbeitet, etc.

Die for-Schleife gehört wie die while-Schleife auch zu den kopfgesteuerten Schleifen, da die Abbruchbedingung vor Betreten des Schleifenkörpers, im Kopf, überprüft wird.

Endlosschleifen

Gelegentlich werden in Programmabläufen auch Endlosschleifen benötigt. Sie werden meist mittels einer while-Schleife realisiert, können jedoch auch durch for-Schleifen erzeugt werden. Hierbei wird auf die Ausdrücke im Schleifenkopf verzichtet, wobei die Semikola jedoch erhalten bleiben:

for (;;) {
    //...
}

Es versteht sich von selbst, dass in diesem Fall innerhalb des Schleifenkörpers für eine Unterbrechung des Schleifendurchlaufs gesorgt werden muss. Dies kann etwa durch die Definition einer Bedingung und das Schlüsselwort break erfolgen:

for(int i=1;;i++) {
    System.out.println(i);
    if(i%10==0) {
        break;
    }
}

In obigem Beispiel wird nur auf die Abbruchbedingung im Schleifenkopf verzichtet. Innerhalb des Schleifenkörpers wird dann der Wert der Zählvariablen abgefragt und auf das Modulo 10 überprüft. Durch break werden erst Verzweigung und dann die Schleife verlassen, sobald i erstmalig durch 10 ganzzahlig teilbar ist. Die Ausgabe liefert somit untereinander auf der Konsole die Zahlen von 1 bis 10.

Neben den bisher genannten sind noch einige Sonderformen der for-Schleife denkbar, die jedoch nur auf den ersten Blick scheinbar vom oben Dargestellten abweichen. Als Beispiel sei hier die Verwendung der Schleife für die Durchläufe eines Iterators angeführt.

TreeSet<String> ts = new TreeSet<String>();
//... 
for (Iterator<String> it = ts.iterator(); it.hasNext();) {
    String s = it.next();
    System.out.println(s);
}

Hier wird statt einer Zählvariablen ein Iterator-Objekt gebildet, dessen Methode hasNext() die Abbruchbedingung stellt.