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

Java Übung 11 – Java Objekte in Java Methoden übergeben

Java Übung Java Methoden Objekte

In dieser Java Übung möchte ich dir zeigen, dass du auch in Klassenmethoden auf Objekte und deren Instanzvariablen zugreifen kannst. Schau dir dazu einmal diesen Java Code an. public class Umwandlung { private int x; public int getX() { // getter Methode return x; } public void setX(int x) { // setter Methode this.x = […]

Die drei Bestandteile aller Java Klassen

Java Klassen Bestandteile

Java ist eine objektorientierte Programmiersprache. Was heißt das? Ja… Anscheinend hat es etwas mit Objekten zu tun. Also was ist ein Objekt? Ein Objekt ist ein bestimmtes Konstrukt im Programm. Bauen wir ein Spiel. Ein Grafik-Adventure. Du kennst das. Ein Held wird in eine bestimmte Spielwelt hinein gesteckt. Der Held muss mit bestimmten Personen sprechen. […]

Das Java Vererbung Konzept in einem Rollenspiel

Java ist eine objektorientierte Programmiersprache. Und das bedeutet nicht nur, dass du Objekte einer Java Klasse erzeugen kannst. Es bedeutet auch, dass Java Klassen von anderen Klassen erben können. Wieso das Ganze? Stell dir einmal ein Rollenspiel vor. Wie würdest du ein Rollenspiel entwerfen? In einem Rollenspiel gibt es magische Gegenstände. Zauberringe, Zauberstäbe, welche bei […]

So nutzt du das Java Keyword public

Java Keyword public

Java Programme bestehen aus Java Klassen. Und der Zugriff auf eine Java Klasse sollte nach außen immer gewährleistet sein. Was bedeutet das? Du solltest in jeder Klasse die Möglichkeit haben, ein Objekt einer anderen Klasse anzulegen. Gerade durch diese Möglichkeit macht doch das ganze Klassenkonstrukt erst Sinn.

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

Java Operatoren

In diesem Beitrag geht es um Java Operatoren. Ich möchte dir gern zwei neue Operatoren vorstellen. Diese nennen sich Inkrement und Dekrement. Ja was heißt das? Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl. Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl. Wozu brauchst du das? Stell dir vor. Du bekommst eine Liste mit Namen […]

Java lernen – 10 nützliche Tipps für Java Anfänger

Java Lernen Anfänger

Wenn du die Programmiersprache Java lernen möchtest, bist du hier prinzipiell erst einmal richtig. Und wenn du es wirklich ernst meinst und in die Java Programmierung einsteigen möchtest, solltest du auch meinen kostenlosen Java Kurs beanspruchen. Wenn du dabei bist, bekommst du: Eine Lektion pro Woche zu den Basics. Hier geht es um die ersten […]

Die mathematischen Grundlagen des Dezimalsystems für Java Programmierer

Java Dezimalsystem Mathematik Programmierer

Bei der Java Programmierung benötigst du Kenntnisse über das Dezimalsystem. Allein schon für die technische Umsetzung beim Runden einer Zahl. Oder du möchtest den Kehrwert bzw. den Umkehrwert einer Zahl im Programm bestimmen lassen. Aber auch für das Herausfinden des Stellenwertes – also wieviel Stellen hat eine Zahl – benötigst du das Grundwissen des Dezimalsystems. […]