Java Foreach

Java foreach einfach erklärt

Mit Hilfe einer foreach-Schleife kannst du mit wenig Code einen bestimmten Programmabschnitt mehrmals ausführen lassen.  Dabei kann dann eine bestimmte Aktion für dessen Werte ausgelöst werden. 

Die Syntax für ein Java Foreach Schleife ist:

for (Datentyp Element : Collection){
     // Bedingung, die Element enthält
}

• Datentyp: Hier muss der Datentyp der Kollektion festgelegt werden.
• Element: Dabei handelt es sich um eine lokale Variable der Schleife.
• Collection: Name der Kollektion, wie beispielsweise der Arrayname.
• Bedingung: Hier wird festgelegt, welche Aktion für die Werte der Kollektion ausgeführt werden soll, auf die du zugreifst. In dem Statement muss das Element bzw. die Bezeichnung der Variablen enthalten sein.

Wichtig: Mit der foreach Schleife lässt sich auf eine Kollektion nur lesend zugreifen und nicht schreibend / manipulierend!

Java for- und foreach-Schleife

Der Java Foreach funktioniert ähnlich wie eine normale for-Schleife und wird oft als eine Art Weiterentwicklung gesehen. Aber worin genau unterscheiden sich die beiden Schleifentypen? Damit du den Unterschied besser verstehen kannst, siehst du hier im weiteren Verlauf das selbe Programm einmal als for- und einmal als for-each-Schleife.

Für das Beispiel benötigen wir zuerst ein Array. Hier  erfährst du, wie du ein Array in Java deklarierst und initialisierst.

Das Array soll eine 4-Reihe der natürlichen Zahlen speichern. Die Array Length beträgt dabei 5. 

public class JavaForSchleife {
     public static void main(String[] args){

          // Deklarierung Array der Länge 5
          int viererReihe [] = new int [5];

          //Initialisierung Array mit einer For-Schleife
          for (int i=0; i < viererReihe.length; i++){
               viererReihe[i] = (i+1) * 4;
          }
     }
}

• Datentyp = int
• Arrayname = viererReihe
• Variable = i

Da wir die Java foreach Schleife nur lesend verwenden können, müssen wir bei der Initialisierung des Arrays also eine normale for-Schleife verwenden.

Mit dem Code ergeben sich für das Array die folgenden Indexpositionen:

Index 0 = 4

Index 1 = 8

Index 2 = 12

Index 3 = 16

Index 4 = 20

Nun soll genau dieses Array ausgegeben werden. Für den Zugriff folgt nun ein Programmcode beider Schleifentypen. 

Zugriff for-Schleife

for (int = 0; i < viererReihe.length; i++){
     System.out.println(viererReihe[i]);
}

• int i = 0: Die Schleifenvariable i startet wie der Index bei 0.
• i < viererReihe.length: Beschreibt die Länge des Arrays – also 5. Da die Schleife bei 0 startet, wird sie damit bei i=4 beendet 
• i++: Variablenerhöhung 
• System.out.println(viererReihe[i]): Alle Werte i des Arrays „viererReihe“ sollen ausgegeben werden.

Wenn du mehr über die for-Schleife in Java erfahren willst, schau dir einfach unser Video dazu an.

Zugriff for-each-Schleife Java

for (int i : viererReihe){
     System.out.println(i);
}

• for: Wie bei einer normalen for-Schleife beginnt der for each-loop auch mit dem Keyword „for“.
• int i : viererReihe: Bei i handelt es sich um eine lokale Variable. Du kannst sie also nenne wie du möchtest. Würdest du das Ganze beispielsweise in int Zahlen : viererReihe umbenennen, würdest du genau das gleiche Ergebnis erhalten. Wichtig ist nur, dass die lokale Variable den selben Datentyp wie die Werte des Arrays besitzen! Nach dem Doppelpunkt wird dann entsprechend der Arrayname platziert.
• System.out.println(i): Alle Werte i werden ausgegeben. Innerhalb der Klammern muss die Bezeichnung der lokalen Variable gesetzt werden. Um das Beispiel von vorhin zu übernehmen, wäre also auch System.out.println(Zahlen) möglich.

Im Gegensatz zur for-Schleife ist bei einem Java foreach also weder ein Startwert, noch eine Abbruchbedingung und auch keine Indexerhöhung nötig.

Die Ausgabe für beide Programme lautet:

4

8

12

16

20

for-each-Schleife – Array primitiver Datentypen

Bei primitiven Datentypen handelt es sich um ganzzahlige Werte (int, short, long, byte), Gleitkommazahlen (float, double), Zeichen (char) und Wahrheitswerte (boolean).

Bei dem vorhergehendem Beispiel handelt es sich also um ein Array primitiver Datentypen. Hier findest du ein weiteres Beispiel, um sie direkt mit den Objektarrays im nächsten Kapitel vergleichen zu können.

// Deklarierung und Initialisierung eines Arrays primitiver Datentypen

int [] array = {1, 2, 3, 4, 5};

// Zugriff auf die Daten mittels der for-each-Schleife

for (int zahlen : array)
     System.out.println(zahlen);

Ausgabe:

1

2

3

4

5

for-each-Schleife – Objektarrays

Aber wie sieht es mit den Objekttypen aus? Als Beispiel siehst du eine for-each-Schleife der Objektklasse String.

// Deklarierung und Initialisierung eines Objektarrays

String [] array = {"Anna", "Hans", "Otto"};

// Zugriff auf die Daten mittels der for-each-Schleife

for (string namen : array)
     System.out.println(namen);

Ausgabe:

Anna

Hans

Otto

Wie du sehen kannst, bleibt der Java foreach für beide Datentypen vom Aufbau her gleich. Es ist nur wichtig, dass der Datentyp des Arrays mit dem Datentyp des foreach-Loops übereinstimmt.

Java HashSet foreach

Bei einem HashSet-Objekt handelt es sich um die Realisierung einer Menge von Objekten.

Der Unterschied zu Arrays besteht hauptsächlich darin, dass

• jedes Element nur einmal vorhanden sein darf
• kein Index vorhanden ist

Würde sich ein Element in der Menge wiederholen, würde es durch den HashSet nicht ausgegeben werden.

for-each-Schleife

Anbei ein Java Programm zur Demonstration der Integration über eine for-each-Schleife.

import java.util.*;

class JavaHashSetForeach{
     public static void main(String [] args){
          //Erstellung und Initialisierung eines HashSets
          HashSet<String> namen = new HashSet<String>();

          namen.add("Anna");
          namen.add("Hans");
          namen.add("Anna");

          // Zugriff auf HashSet über die for-each-Schleife 
          for (String i : namen)
               System.out.println(i);
     }
}

Ausgabe:

Anna

Hans

Erklärung: Durch das HashSet wird der doppelte Wert „Anna“ aussortiert und nur einmal ausgegeben.

forEach() Methode

Die forEach() Methode ist erst ab Java 8 verfügbar und gehört zur Iterable-Schnittstelle.

Hier findest du ein Beispiel für eine Java HashSet foreach Methode:

import java.util.*;

class JavaHashSetForeach{
     public static void main (String[] args){
          //Erstellung und Initialisierung eines HashSets
          HashSet<String> namen = new HashSet<String>();

          namen.add("Anna");
          namen.add("Hans");
          namen.add("Anna");
     
          // Zugriff auf HashSet über die forEach() Methode 
          namen.forEach(namen -> System.out.println(namen));
     }
}

Ausgabe:

Anna

Hans

Erklärung: Durch das HashSet wird der doppelte Wert „Anna“ aussortiert und nur einmal ausgegeben.

Java HashMap foreach

Bei einer HashMap handelt es sich um einen Container, in dem Schlüsselwert-Paare gespeichert werden. Dabei muss jeder Schlüssel eindeutig sein. 

import java.util.Map;
import java.util.HashMap;

class JavaHashMapForeach{
     public static void main (String[] args){
          Map<String,String> m = new HashMap<String,String>();

          m.put("Java", "foreach");
          m.put("Sortieralgorithmus","Bubblesort");

          //Zugriff auf HashMap über for-each-Schleife
          for (Map.Entry<String,String> entry : m.entrySet())
                 System.out.println(entry.getKey() + entry.getValue())
     }
}

Ausgabe:

Java foreach

Sortieralgorithmus Bubblesort