Skip to main content

Java For Each Schleife – Aufbau und Funktionsweise

In einer anderen Lektion habe ich dir bereits gezeigt, wie du ein Java Array mit einer for-Schleife füllen und dir später die Werte zurückgeben lassen kannst.

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.

Java for each Schleife füllen

Im Schleifenrumpf wird jetzt der Wert für "i" eingesetzt.
Und zwar direkt in die Gleichung.
Somit ergibt die Gleichung (0+1)*6 = 6.

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.

Java for each Schleife zweiter Durchlauf

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.

Java for each Lesen

Im Schleifenrumpf wird jetzt das Fach ausgelesen an der Stelle i=0.
Also wird über die System.out.println()-Anweisung der Wert 6 ausgegeben.
Danach wird "i" um eins erhöht.

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.

Java for each Schleife füllen

Und hier der erste Durchlauf der for-each-Schleife.
Java for each Array lesen

Bei der foreach Schleife wird vor dem Schleifenstart immer geprüft ob das angegebene Array (rechts des Doppelpunktes) bereits komplett durchlaufen wurde.

  • 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.

Java for each Array lesen

Zurück zum Bild.
Okay wir sind also in der Schleife.
Dann wird aus dem ersten Fach des Java Arrays gelesen.
Dieser hat den Wert 6.

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.

Java for each Schleife zweiter Durchlauf

Und hier die for each Schleife mit i =6.
Java for each Array auslesen

Wieder entscheidet die Schleife, dass das Array noch nicht komplett durchlaufen wurde.
Und jetzt wird das zweite Fach - sechserReihe[1] - ausgelesen.
Der Wert 12 steckt drin.
Und wieder wird der Wert der lokalen Variable "i" überschrieben.
Jetzt hat "i" den Wert 12 und dieser wird im Schleifenrumpf durch die print-Anweisung ausgegeben.

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.

Ähnliche Beiträge

8 Java Datentypen, die du kennen solltest

Java Datentypen

Java Datentypen Ich gebe zu, ich hasse dieses Thema. Denn es ist eigentlich nichts weiter als graue Theorie. Dennoch müssen wir dieses Thema behandeln. Um schnell in das Thema zu kommen, stelle ich dir eine Übersicht aller primitiven Datentypen zur Verfügung. Wieso primitive? Es gibt außer den primitiven Datentypen, noch Referenztypen. Und diese Referenztypen sind […]

So kannst du deine Java Methoden ausführen

Java Methoden ausführen

Du hast die ersten Java Methoden erstellt. Doch wie greifst du jetzt auf diese zu? Wie kannst du diese Methoden in einer anderen Klassen aufrufen? Welcher Unterschied, hinsichtlich des Methodenaufrufes, besteht eigentlich zwischen deinen Java Methoden? Diese Fragen möchte ich gern in diesem Beitrag beantworten. Gehen wir dazu in den Garten und schauen uns Blumen […]

Java Strings landen im String Constant Pool

Java-Strings-Pool

Du kennst das. Es ist abends. Du sitzt gemütlich vor dem Fernseher. Das Smartphone bimmelt. Kein Anruf. Nein – Eine Nachricht. Du liest die Nachricht sofort und antwortest darauf. Minuten später bekommst du die nächste Nachricht. Und auch auf diese antwortest du. Im Laufe des Abends entsteht daraus eine nette kleine Konversation. Und eh du […]

Java for Schleifen schachteln – So funktioniert es

Java For Schleifen schachteln

Diese Situation kennst du doch auch…. Du stehst an der Haltestelle und wartest auf den Bus. Dein Blick fällt auf die Uhr.   Oder du wartest an der Ecke auf deinen Freund oder Kollegen. Immer wieder schaust du auf deine Uhr.   Sie ist kaum noch wegzudenken. Die mobile Taschenuhr.   Lange Zeit wurde die […]

Java Übung 31: Speichere deine Würfe im Array

Java Übung Array Würfelspiel

In dieser Java Übung soll ein Würfelspiel simuliert werden. Lege eine Klasse namens, Würfelspiel an. Diese Klasse enthält eine statische Methode, namens würfeln(). Diese Methode erwartet einen Parameter vom Datentyp Integer, namens „anzahlWuerfe“. Diese Variable/Parameter repräsentiert die Anzahl der Würfe. Nachdem der Methode die Anzahl der Würfe übergeben wurde, soll die Methode Zufallszahlen zwischen 1 […]

Java Binärzahl in Dezimalzahl umwandeln – So geht’s.

Java-Binärzahl-umrechnen

Erinnerst du dich? In einer der letzten Beiträge haben wir uns die Zusammenhänge zwischen dem dualen und dem dezimalen Zahlensystem angeschaut. Aber wir haben noch keine Java Binärzahl in eine Dezimalzahl verwandelt. Zumindestens nicht praktisch…. Stattdessen…. Haben wir festgestellt, dass beide Zahlensysteme im Grunde genommen sehr ähnlich sind. Beim Dezimalsystem spielt die Zahl 10, als […]

Verwalte deine Java Klassen in packages

java klassen verwalten

Es macht durchaus Sinn deine Java Klassen in verschiedenen Paketen zu organisieren. Wieso? Es sprechen mehrere Gründe dafür: Du kannst doppelte Klassennamen verwenden Du kannst deinen Code oder deine Klassen inhaltlich trennen Du kannst Hierarchien abbilden. Und genau um diese Dinge geht es in diesem Beitrag

Beim Aufruf werden Java Methoden auf dem Stack gestapelt

Java Methoden gestapelt

Java Methoden werden beim Aufruf gestapelt. Und jedes Element auf dem Stapel nimmt Speicherplatz weg. Und manchmal ist es so, dass der Stapel richtig hoch wird und dann…. Ja was passiert eigentlich dann? Betrachten wir einmal ein Computerspiel. Irgendeines. In diesem Computerspiel gibt es Vögel, welche abgeschossen werden sollen. Was bedeutet das denn genau? Beim […]

Du bekommst was du vereinbarst – Die Rückgabewerte von Java Methoden

Java Methoden Rückgabetypen

Was du vereinbarst, das bekommst du zurück. Ach wäre es schön, wenn alles im Leben so funktionieren würde. Aber zum Glück funktioniert dieses Prinzip bei deinen Java Methoden. Denn du kannst den Rückgabetypen im Methodenkopf vereinbaren. Doch bevor ich dir zeige, wie du den Rückgabetypen anlegen kannst…. Lass mich dir zeigen, wofür du den Kram […]