Streams in Java
Du startest eine Pipeline aus einer Liste mit stream(), behältst oder änderst Elemente und druckst danach. In Pipe.java behältst du die public Klasse Pipe, importierst java.util.ArrayList, speicherst "oak" und "pine" und rufst names.stream().filter(n -> n.startsWith("o")).forEach(n -> System.out.println(n)); auf. Kompiliere mit javac Pipe.java und starte java Pipe. Der Bildschirm sollte oak zeigen. Eine zweite Demo nutzt map, sodass der Bildschirm OAK, dann PINE zeigt. Lass optionale Records für die nächste Seite. Diese Lektion ist eine Stream-Pipeline, kein schlichtes forEach auf der Liste und keine Generics-get(0)-Demo.
Filter: ein passendes Wort
Öffne Pipe.java. Behalte den public Klassennamen Pipe. Lösche übrige reine-Cue-Lambda-Demos, übrige Bin-Generics-Drucke, übrige Programmargumente-Flag-Läufe und übrige Box-Scanner-Prompts, wenn sie die Streams-Geschichte verdecken. Das Programm darf nicht auf Tippen warten und braucht keine Startwörter.
Füge oben den Import hinzu:
import java.util.ArrayList;
In Pipe.main baust du eine typisierte Liste mit zwei Wörtern und startest einen Stream, der Wörter mit Anfang o behält:
ArrayList<String> names = new ArrayList<>();
names.add("oak");
names.add("pine");
names.stream().filter(n -> n.startsWith("o")).forEach(n -> System.out.println(n));
stream() öffnet die Pipeline. filter behält Elemente, deren Lambda true liefert. forEach druckt jedes behaltene Element. "oak" beginnt mit o. "pine" nicht. Der Bildschirm zeigt oak.
import java.util.ArrayList;
public class Pipe {
public static void main(String[] args) {
ArrayList<String> names = new ArrayList<>();
names.add("oak");
names.add("pine");
names.stream().filter(n -> n.startsWith("o")).forEach(n -> System.out.println(n));
}
}
Im Ordner mit Pipe.java führst du javac Pipe.java aus. Wenn Klammern und Semikolons passen, schreibt javac keine eigene Zeile. Dann startest du java Pipe — nicht java Pipe.java. Behalte eine public Klasse, damit der Name zu Pipe passt.
Geh den Lauf einmal durch. Java startet in Pipe.main. Die Liste enthält "oak" und "pine". stream() beginnt. filter behält "oak". forEach druckt oak. Es druckt nicht beide Wörter. Nichts ruft nur names.forEach ohne stream() auf. Nichts liest args[0].
Sag dir die Anfängerregel beim Bildschirm: stream() startet die Pipeline; filter wählt; forEach endet mit Druck als Nebeneffekt. Erfinde keine Records-Demos auf dieser Seite. Records wartet auf die nächste optionale Lektion. Lass stream() nicht weg und erwarte nicht, dass filter hier direkt an der Liste hängt.
Siehst du noch oak dann pine aus einer übrigen Cue-forEach-Datei, wechsle zu Pipe und behalte den filter-Schritt. Lehnt javac stream ab, prüfe, dass die Liste ArrayList ist und der Aufruf names.stream() heißt.
Map: jedes Wort in Großbuchstaben
Behalte dieselbe public Klasse Pipe. Ändere die Pipeline so, dass jedes Wort transformiert wird statt gefiltert:
names.stream().map(n -> n.toUpperCase()).forEach(n -> System.out.println(n));
Behalte "oak" und "pine" in der Liste. Kompiliere erneut mit javac Pipe.java und starte java Pipe. Der Bildschirm zeigt OAK, dann PINE. map liefert einen neuen Wert pro Element. forEach druckt diese Werte in Reihenfolge.
import java.util.ArrayList;
public class Pipe {
public static void main(String[] args) {
ArrayList<String> names = new ArrayList<>();
names.add("oak");
names.add("pine");
names.stream().map(n -> n.toUpperCase()).forEach(n -> System.out.println(n));
}
}
Geh den Lauf einmal durch. Der erste gemappte Wert ist OAK. Der zweite ist PINE. Behalte beide Demos als zwei Lehrformen. Zuerst zeigst du, dass filter ein Wort behält. Dann zeigst du, dass map jedes Wort ändert. Beide teilen Import, typisierte Liste, stream() und ein terminierendes forEach.
Verkettst du später filter und map in eigenen Experimenten, zählt die Reihenfolge. Diese Seite lässt pro Demo einen Zwischenschritt, damit der Bildschirm lesbar bleibt.
Pipeline-Gewohnheiten
Behalte die Schritte in Reihenfolge beim Üben.
📊 Stream-Gewohnheiten für Pipe
| Step | Call | Beginner check |
|---|---|---|
| Start | names.stream() |
opens the pipeline from the list |
| Keep some | filter(n -> ...) |
lambda returns true to keep |
| Change each | map(n -> ...) |
lambda returns the new value |
| Finish print | forEach(n -> System.out.println(n)) |
terminal step that prints |
Skip stream() |
list has no filter in this shape |
put stream() before filter or map |
Streams ist nicht nur Lambda und nicht Records
Lambda lehrte forEach direkt auf der Liste. Streams setzt stream() zuerst, damit du vor dem finalen forEach filter oder map nutzen kannst. Records führt später auf einer optionalen Seite einen kompakten Datentyp ein. Mische diese drei Aufgaben heute nicht in einer Anfängerdatei.
oak, das filter behält, ist ein Listenelement in der Pipeline. Es ist kein args[0] von Flag. Druckt eine übrige Cue-Datei jedes Element ohne Filter, lass das als Historie und behalte Pipes Zeile stream().filter.
Ohne stream() sind die filter- und map-Aufrufe dieser Seite nicht die Lehrform. Ohne terminierendes forEach druckt die Pipeline nicht. Behalte beide Enden der Pipeline zusammen beim Üben. Lass Records-Syntax bis zu dieser Lektion von dieser Seite weg, auch wenn du woanders schon eine Überschrift zu kompakten Datentypen gesehen hast.
Ordnerchecks vor Records
Liste den Ordner nach erfolgreichem Kompilieren. Du solltest Pipe.java und Pipe.class zusammen sehen. Bearbeite die Quelle, speichere, führe javac Pipe.java aus, dann java Pipe. Eine alte .class kann noch den Filter-Bildschirm zeigen, wenn du nach dem Wechsel zu map nicht neu kompilierst.
Beschwert sich javac über doppelte public Klassen, bleib nur Pipe public. Zeigt der Bildschirm bei der Filter-Demo oak und pine, fehlt vielleicht startsWith("o") — stelle das Filter-Lambda wieder her. Druckt nichts, prüfe, dass add vor stream() lief.
Klebe Cues Listen-forEach nicht als Ersatz für die ganze Pipeline auf dieser Seite. Klebe nicht Bins get(0) in Pipe. Die optionale Streams-Aufgabe ist stream plus ein Zwischenschritt plus forEach.
Vor optionalen Records
Du kannst public Klasse Pipe behalten, ArrayList importieren, "oak" und "pine" hinzufügen, names.stream().filter(n -> n.startsWith("o")).forEach(...) aufrufen, oak sehen, dann names.stream().map(n -> n.toUpperCase()).forEach(...) aufrufen und OAK dann PINE sehen. Kompiliere mit javac Pipe.java und starte java Pipe. Die Tabelle trennt Start, Filter, Map und Ende. Die nächste optionale Seite ist Records.
Behalte die Pipe-Demos als klares Streams-Paar. Halte Cue-Lambda-Dateien von dieser Seite fern, wenn du Pipelines übst. Halte Bin-Generics-Dateien von dieser Seite fern, wenn du Pipelines übst. Halte Records-Arbeit bis zu dieser Lektion von dieser Seite fern. Diese Gewohnheiten sind der Checkpoint vor dem Weitergehen. Zeigt der Filter-Bildschirm oak oder der Map-Bildschirm OAK dann PINE, hat Streams für diese Lektion seine Arbeit getan und du bist bereit für Records auf dem optionalen Pfad.
Ein letzter Blick in den Ordner: eine public Pipe, Import da, typisierte ArrayList<String>, stream() vor filter oder map, terminierendes forEach, kein Scanner-Warten, keine Startwörter nötig. Führe javac Pipe.java und java Pipe noch einmal auf der Demo aus, die du offen hast. Zeigt der Bildschirm weiter oak oder OAK dann PINE, ist die Streams-Form solide und der Kurs kann auf der nächsten Seite zu optionalen Records weitergehen. Bevorzuge eine klare Pipeline-Gewohnheit pro Durchgang, damit jeder Pass dieselbe Map lehrt.
🧠 Testen Sie Ihr Wissen
Testen Sie Ihr Wissen
Fordern Sie sich mit diesem interaktiven Quiz heraus und sehen Sie, wie gut Sie das Thema verstehen
📝 Anweisungen
- Lesen Sie jede Frage sorgfältig
- Wählen Sie die beste Antwort für jede Frage
- Sie können das Quiz so oft wiederholen, wie Sie möchten
- Ihr Fortschritt wird oben angezeigt