So kannst du die Java For Each Schleife anlegen und für Arrays nutzen

Es gibt allerdings einen weiteren Schleifentyp, welche geradezu prädestiniert ist für Java Arrays.
Dieser Schleifentyp nennt sich for each Schleife.

In diesem Beitrag möchte ich dir zeigen, wie du so eine for-each-Schleife erstellst und welche Unterschiede zur for-Schleife bestehen.
Außerdem möchte ich dann noch ein paar Dinge zur Funktionsweise und Aufbau loswerden.

Aber am Beispiel….

Java for each Schleife am praktischen Beispiel

Nehmen wir an:
Ich möchte mir an der Konsole die 6-Reihe der natürlichen Zahlen anzeigen lassen.
Vielleicht die ersten 10 Zahlen der ganzen Reihe.
Also 1* 6, 2 *6 usw. – bis 10 * 6.

Diese Zahlen sollen in einem Array gespeichert werden.
Also wie machst du das?

Als Erstes brauchst du ein Array.
Der Datentyp, welcher ins Array soll, ist ganzzahlig und somit Integer.
Um 10 Zahlen speichern zu können, braucht das Array 10 Fächer.
Logisch, oder?

Da das erste Fach an der Stelle 0 (Index 0) liegt, beträgt die Gesamtlänge des Arrays 10.
Das letzte Fach hat allerdings den Index 9.

public class JavaForEach {
	
	public static void main(String[] args) {
		int sechserReihe [] = new int[10]; //neues Integer-Array mit 10 Fächern
		
	}
}

Da ich später aus dieser Klasse heraus, auch das Programm starten will – muss die main-Methode in die Klasse implementiert werden.

So das Array und der Programmstart sind gebongt.
In den Fächer des Java Arrays stecken am Ende unseres Beispiels folgende Werte:

1. Fach 0 = 6
2. Fach 1 = 12
3. Fach 2 = 18
4. Fach 3 = 24
5. Fach 4 = 30
6. Fach 5 = 36
7. Fach 6 = 42
8. Fach 7 = 48
9. Fach 8 = 54
10. Fach 9 = 60

Ich hoffe, dass ich mich nirgendwo verrechnet habe.
Aber somit sind die ersten zehn Zahlen der 6-Reihe, in den zehn Fächern des Arrays verteilt.

Okay, wie kriegen wir diese Zahlen nun in das Array?
Ja na klar – Mit einer Schleife.

Da sich die for-each Schleife von der for-Schleife ableitet, beginnen wir das Beispiel mit der for-Schleife.

Okay, dann mal los.

Da das erste Fach den Index Null trägt, muss die Zählvariable „i“ auch bei Null starten.
Somit lautet die Schleifenvariable: int i =0

Die Schleife soll alle 10 Fächer durchlaufen.
Und die Länge des Arrays, die Fächeranzahl „10“, steckt in der Variable „sechserReihe.length“.

Beachte aber bitte, dass die Schleife bei i=0 startet und somit bei i = 9 endet.
Die Bedingung lautet somit: i < sechserReihe.length

Bei jedem Durchlauf soll sich i um eins erhöhen.
Und zwar solange bis i = 9 ist.
Somit lautet die Variablenerhöhung - i++.

public class JavaForEach {
	
	public static void main(String[] args) {
		int sechserReihe [] = new int[10];
		
		//For-Schleife füllt das Array mit der 6-Reihe
		for (int i = 0; i < sechserReihe.length; i++){
			sechserReihe[i] = (i+1) * 6;
		}
	}
}

Im Rumpf der Schleife wird dann das Array an der Stelle i gefüllt.
Aufgrund dessen, dass die Zählvariable bei 0 startet - kannst du diese nicht ohne Weiteres als Faktor verwenden.
(i * 6) wäre dann im ersten Durchlauf = 0.

Wir wollen allerdings beim Ergebnis von 6 starten und müssen somit i um eins erhöhen.
(i+1) * 6.

Eine zweite for-Schleife liest das Array an der Stelle i aus.

BÄÄM - hier ist die zweite Schleife.

public class JavaForEach {
	
	public static void main(String[] args) {
		int sechserReihe [] = new int[10];
		
		//For-Schleife füllt das Array mit der 6-Reihe
		for (int i = 0; i < sechserReihe.length; i++){
			sechserReihe[i] = (i+1) * 6;
		}
		
		//For-Schleife liest das Array und gibt Werte zurück
		for (int i =0; i< sechserReihe.length; i++){
			System.out.println(sechserReihe[i]);
		}
	}
}

Und jetzt klicke einmal auf "RUN"!
Läuft?

Aber ich wollte dir keine for-Schleife zeigen, sondern die for-each-Schleife.

Dennoch muss dir die Funktionsweise der for-Schleife klar sein.
Wie sie funktioniert und wie du diese aufbaust - muss einfach sitzen.
Ansonsten wird dir später nicht klar, welcher Unterschied zur for-each-Schleife besteht.

Auch auf die Gefahr hin, dass du jetzt sagst - "NICHT SCHON WIEDER" - spiele ich die ersten zwei Durchgänge der for-Schleifen einmal durch.

Danach komme ich endlich zur For-each-Schleife - Versprochen.

Wie die for-Schleifen das Array füllen und aus dem Java-Array lesen.

Hier nochmal der bisherige Java Code:

public class JavaForEach {
	
	public static void main(String[] args) {
		int sechserReihe [] = new int[10];
		
		//Füll-Schleife
		for (int i = 0; i < sechserReihe.length; i++){
			sechserReihe[i] = (i+1) * 6;
		}
		
		//Lese-Schleife
		for (int i =0; i< sechserReihe.length; i++){
			System.out.println(sechserReihe[i]);
		}
	}
}

Beginnen wir bei der ersten Schleife - der Füllschleife.
Die Zähl- oder Indexvariable startet bei 0.
Denn int i = 0.

Dann wird die Schleifenbedingung geprüft.
"I" ist kleiner als sechserReihe.length
Denn in der Variable length steckt die Länge des Arrays und somit der Wert 10.
Und 0 ist kleiner als 10.
Also ab in die Schleife.

Außerdem wird der Wert aus "i" zur Fachbelegung sechserReihe[0] herangezogen
Das erste Fach mit dem Index Null wurde somit mit dem Wert 6 gefüllt.

Am Ende der Schleife wird i um eins erhöht.
Und im nächsten Durchlauf startet i mit dem Startwert i = 1.

Im zweiten Druchlauf lautet der Startwert i =1

Auch jetzt noch ist i kleiner als zehn.
Das Programm springt somit abermals in die Schleife.

Anstelle von "i" wird jetzt die 1 im Schleifenrumpf eingesetzt und (1+1) * 6 = 12.
Somit landet im zweiten Fach sechserReihe[1] der Wert 12.
Und schließlich wird i wieder um eins erhöht.

Nachdem die Schleife 10 mal durchlaufen wurde, springt das Programm aus dieser heraus.

Und dann geht es direkt weiter mit der zweiten for-Schleife.
Diese liest das Array aus und gibt die Werte auf der Konsole aus.

Also schauen wir uns den ersten Durchgang der Leseschleife einmal an.
Auch die Leseschleife startet bei i = 0.

Beim nächsten Durchgang würde der Wert aus dem zweiten Fach gelesen werden.
Und nach 10 Durchgängen ist auch hier Schluss.

Aufbau einer Java for each Schleife

Und jetzt endlich schauen wir uns die for-each-Schleife an.
Hier ist sie:

public class JavaForEach {
	
	public static void main(String[] args) {
		int sechserReihe [] = new int[10];
		
		//For-Schleife füllt das Array mit der 6-Reihe
		for (int i = 0; i < sechserReihe.length; i++){
			sechserReihe[i] = (i+1) * 6;
		}
		
		for ( int i : sechserReihe){
			System.out.println(i);
		}
	}
}

Die for-each-Schleife beginnt ebenfalls mit dem Keywort for.

Dann folgt eine Klammer.
In der Klammer befindet sich links eine lokale Variable, welche ich "i" nenne.
Dies ist keine Index- oder Zählvariable.

Dann folgt der Doppelpunkt.
Und rechts befindet sich die Referenzvariable zum Array.
Im Rumpf wird jetzt der Wert, welcher in "i" steckt ausgegeben.

Klicke also einmal auf "RUN" und probiere es selbst aus.
Und läuft, oder?

Die Foreach Schleife durchläuft ebenfalls das komplette Java Array

Allerdings mit einigen Unterschieden.
"I" ist lediglich eine lokale Variable.

Am besten lässt es sich direkt beim Schleifendurchlauf verdeutlichen.
Hier nochmal der erste Durchlauf der for-Schleife.

• Falls nicht - geht es in die Schleife.
• Falls alle Fächer durchlaufen wurden, springt das Programm aus der Schleife.

public class JavaForEach {
	
	public static void main(String[] args) {
		int sechserReihe [] = new int[10];
		
		//For-Schleife füllt das Array mit der 6-Reihe
		for (int i = 0; i < sechserReihe.length; i++){
			sechserReihe[i] = (i+1) * 6;
		}
		
		for ( int i : sechserReihe){
			System.out.println(i);
		}
	}
}

Du siehst den Unterschied im Code und im Bild.
Bei der for-Schleife musst du immer:

• den Startwert bzw. den Index- int i = 0
• eine Abbruchbedingung - i < sechserReihe.length
• Sowie die Index-erhöhung i++ festlegen

Bei der for-each Schleife musst du dies nicht.
Es wird alles automatisch java-intern geregelt.

Und jetzt kommt es.
Die Variable "i" wird mit dem Wert 6 überschrieben.
Somit trägt der Startwert für den nächsten Durchlauf 6.

Also dann zweiter Durchlauf.
Hier nochmal die for-Schleife mit i=1.

Was sagt uns das jetzt?

"I" ist keine Zähl- oder Indexvariable.
Stattdessen handelt es sich um eine ganz normale lokale Variable, welche innerhalb der Schleife, den jeweiligen Wert des Faches ausgibt.

Um es mal deutlicher zu machen.
Du hättest das Ding auch sonst wie nennen können.
Beispielsweise "ersteZahl".

public class JavaForEach {
	
	public static void main(String[] args) {
		int sechserReihe [] = new int[10];
		
		//For-Schleife füllt das Array mit der 6-Reihe
		for (int i = 0; i < sechserReihe.length; i++){
			sechserReihe[i] = (i+1) * 6;
		}
		
		for ( int ersteZahl : sechserReihe){
			System.out.println(ersteZahl);
		}
	}
}

Die lokale Variable ist keine Start-, Zähl- oder Indexvariable - wie in einer for-Schleife.
Stattdessen ist es eine Variable, welche bei jedem neuen Schleifendurchlauf überschrieben wird.
Und zwar immer mit dem Wert des aktuellen Array-Faches.

Ein Java Array mit einer for each Schleife füllen

Das geht nicht.
Es fehlt die Indexvariable, welche auf das Fach zugreifen kann.

Ich sagte ja bereits, dass die Zählvariable bzw. Indexvariable fehlt.
Natürlich könntest du diese künstlich anlegen und hochzählen lassen.
So wie hier:

public class JavaForEach {
	
	public static void main(String[] args) {
		int sechserReihe [] = new int[10];
		
		//For-each Schleife zum Schreiben
		int i = 0;//zusätzliche Zähl- oder Indexvariable
		for (int ersteZahl : sechserReihe){
			sechserReihe[i]= (i+1)*6;
			i++;
		}
		
		//for each Schleife zum Lesen
		for ( int ersteZahl : sechserReihe){
			System.out.println(ersteZahl);
		}
	}
}

Aber dadurch hat dieser Schleifentyp keinen Vorteil mehr gegenüber einer ganz normalen for-Schleife.

Also wo liegen jetzt die Vorteile gegenüber einer for Schleife.

Im schnellen Handling.

• Du musst keine Abbruchbedingung festlegen.
• Es wird immer das komplette Array durchlaufen.
• Außerdem brauchst du keinen Startwert.
  Die for each Schleife startet immer beim ersten Fach.
• Und um die Erhöhung der Zählvariablen brauchst du dich auch nicht kümmern.
  Es wird immer das komplette Array durchlaufen.

Wo Licht ist, da ist auch Schatten.

Und natürlich gibt es Nachteile:
Das Array wird immer vom ersten bis zum letzten Fach durchlaufen.
Somit kannst du wirklich nur Standarddurchläufe realisieren.

Natürlich kannst du dir auch Konstrukte schaffen, welche vom Standard abweichen.
Aber auch dann verliert dieser Schleifentyp seinen Vorteil.

Eins Noch - Die Variable muss zum Array passen.

Hier am Beispiel eines String-Arrays.

public class JavaForEach {
	
	public static void main(String[] args) {
		String namen [] = new String [2];//String Array
		namen[0]="Matze";
		namen[1]="Mathias";
		
		//for each Schleife zum Lesen
		for ( String z : namen){
			System.out.println(z);
		}
	}
}

Die Variable "z" ist vom selben Datentyp - wie die Werte im Array.
Ganz logisch.
Denn diese Variable bekommt ja schließlich auch jeden einzelnen Wert im Array nacheinander zugewiesen.

Zusammenfassung:

• Die foreach Schleife ist eine wunderbare Möglichkeit, um ein Array auszulesen bzw. zu durchlaufen.
• Aufgrund dessen, dass du dich überhaupt nicht um den ganzen Schleifenkopf kümmern musst - kannst du diese Schleifen bei allen Standarddurchläufen nutzen.

Über den Autor

Folge Sciodoo und bleibe stets auf dem Laufenden. Schließ dich uns an und abonniere unseren Instagram-Kanal ein. Wir stellen täglich neue Artikel für dich rein. Weiter zum Kanal>>>