Ullrich: /* Mach' was mit: Verarbeitung der Objekte */

2023-09-24T17:26:42Z

Mach' was mit: Verarbeitung der Objekte

← Nächstältere Version		Version vom 24. September 2023, 17:26 Uhr
Zeile 237:		Zeile 237:
	für Parallelisierung gewappnet; falls das eines Tages gewünscht sein sollte.		für Parallelisierung gewappnet; falls das eines Tages gewünscht sein sollte.

	=== Mach' was ~~mit~~: Verarbeitung der Objekte ===		=== Mach' was damit: Verarbeitung der Objekte ===
	''Ein'' Use Case für Streams ist die Verarbeitung einer Menge von Objekten. Hierfür dient die Methode {{java\|foreach()}}. Als		''Ein'' Use Case für Streams ist die Verarbeitung einer Menge von Objekten. Hierfür dient die Methode {{java\|foreach()}}. Als
	Parameter dient ein λ-Ausdruck das das Interface {{java\|Consumer{{java\| implementiert. Es nimmt ein Objekt des Eingabe-Stroms		Parameter dient ein λ-Ausdruck das das Interface {{java\|Consumer{{java\| implementiert. Es nimmt ein Objekt des Eingabe-Stroms

Ullrich am 29. Juli 2020 um 19:15 Uhr

2020-07-29T19:15:22Z

← Nächstältere Version		Version vom 29. Juli 2020, 19:15 Uhr
Zeile 5:		Zeile 5:
	elegantem, übersichtlichem Code; darauf liegt das Augenmerk dieses Beitrags. Er ist als Einführung zu betrachten		elegantem, übersichtlichem Code; darauf liegt das Augenmerk dieses Beitrags. Er ist als Einführung zu betrachten
	und kann daher nicht alle Aspekte beleuchten. Es wird vielmehr versucht das abstrakte Konzept zu beschreiben,		und kann daher nicht alle Aspekte beleuchten. Es wird vielmehr versucht das abstrakte Konzept zu beschreiben,
	nicht wie die Verarbeitung durch die JDK-Implementierung geschieht..		nicht wie die Verarbeitung durch die JDK-Implementierung geschieht.

	Der Begriff "Stream" wird unglücklicherweise für zwei verschiedene Dinge verwendet. Zum einen ist damit der		Der Begriff "Stream" wird unglücklicherweise für zwei verschiedene Dinge verwendet. Zum einen ist damit der

Ullrich: Die Seite wurde neu angelegt: „Category:Java Man kann Java-8-Streams als ein Konzept beschreiben, mit dem eine Menge von Objekten in gleichartiger Weise verarbeitet werden kann. Die Vera…“

2020-07-29T17:08:52Z

Die Seite wurde neu angelegt: „Category:Java Man kann Java-8-Streams als ein Konzept beschreiben, mit dem eine Menge von Objekten in gleichartiger Weise verarbeitet werden kann. Die Vera…“

Neue Seite

[[Category:Java]]
Man kann Java-8-Streams als ein Konzept beschreiben, mit dem eine Menge von Objekten in gleichartiger Weise
verarbeitet werden kann. Die Verarbeitung muß nicht unbedingt sequentiell erfolgen, Tatsächlich wurden Streams
als Konzept für die parallele Verarbeitung eingeführt. Die Verarbeitung von Listen mit Java-Steams führt zu
elegantem, übersichtlichem Code; darauf liegt das Augenmerk dieses Beitrags. Er ist als Einführung zu betrachten
und kann daher nicht alle Aspekte beleuchten. Es wird vielmehr versucht das abstrakte Konzept zu beschreiben,
nicht wie die Verarbeitung durch die JDK-Implementierung geschieht..

Der Begriff "Stream" wird unglücklicherweise für zwei verschiedene Dinge verwendet. Zum einen ist damit der
Strom der Objekte gemeint, die verarbeitet werden sollen. Das ist mehr eine bildliche Vorstellung dessen, was im
Innern der Stream-Implementierung passiert, denn so etwas wie eine "Röhre", durch die die Objekte im
Wortessinne hindurchschwimmen existiert im Java-Programm natürlich nicht. Zum anderen ist damit ein Java-
Objekt gemeint, das das Stream-Interface implementiert. Das ist tatsächlich etwas, das man im Java-Code
wiederfindet, anfassen und verwenden kann. Im Folgenden wird der Begriff "Stream" für das verarbeitende Java-
Objekt verwendet und der Begriff "Strom" für den Objekt-Strom. "Stream" kann auch als Bezeichnung für das
Stream-Konzept als Ganzes stehen.

Man kann sich das Stream-Objekt wie ein Rohrleitungssystem vorstellen, in das ein Strom von Objekten
hineingeschüttet wird. Beim Durchlaufen wird der Strom gefiltert, eingekocht und mit Zusätzen angereichert. Das
Leitungsende verschließt ein Stöpsel mit einem Hahn, der nur die Tropfen durchläßt, die das vollständige
Rohrsystem passiert haben und das Ergebnis bilden. Die Art der Flüssigkeit kann sich beim Durchlaufen des
Leitungssystems ändern – aber lassen wir uns durch das Bild nicht zu weit von den Streams fortspülen...

== Wie die Verarbeitung abläuft ==
Die Verwendung eines {{java|Stream}}-Objekts besteht aus drei Schritten:

Im ersten Schritt muß zunächst ein {{java|Stream}}-Objekt erzeugt werden, mit dem die Objekte verarbeitet werden
können. Diesem {{java|Stream}}-Objekt werden dann im zweiten Schritt Arbeitsanweisungen hinzugefügt die angeben, was
mit den Objekten geschehen soll, die später als "Strom" durch die gedachte Röhre fließen. Sie können Objekte
verändern, umwandeln, Objekte herausfiltern und vieles mehr. Der dritte Schritt schließt die Verarbeitung durch
eine Anweisung ab, die den Ergebnis-Strom "abfüllt". Man kann den gesamten Strom auf Flaschen ziehen (also zum
Beispiel alle verarbeiteten Objekte in eine Liste füllen), ein einzelnes Objekt herauspicken oder den Strom auf eine
einzige Eigenschaft des Ergebnis-Stroms reduzieren (zum Beispiel auf die Anzahl der enthaltenen Objekte).
Abweichend von der Analogie muß man man sich bereits beim Erzeugen des {{java|Stream}}-Objekts entscheiden, welche
Objekte man durch die Rohrleitung schickt. Glücklicherweise ist die Erzeugung eines {{java|Stream}}-Objekts aber deutlich
einfacher als die Installation einer sanitären Anlage...

Typischerweise schreibt man die komplette Verarbeitung via Method-Chaining in eine einzige Anweisung. Das
Zählen aller Zahlen einer Liste die größer als 100 sind, könnte zum Beispiel so aussehen (die Erklärung der
Methoden folgt später):
{{java|code=Stream.of(10, 4711, 815).filter(x -> x > 100).count();}}
Der Strom der Objekte beginnt tatsächlich erst zu fließen, wenn die abschließende Methode von Schritt drei
aufgerufen wird (im Beispiel ist das die Methode {{java|count()}}). Man muß die Methoden daher nicht unmittelbar
hintereinenader ausführen, sondern kann – wenn erforderlich – die Konstruktion des {{java|Stream}}-Objekts schrittweise
ausführen und dann durch Ausführen der Abschluß-Methode die Verarbeitung starten. In der Rohrleitungs-Analogie
wird das Leitungssystem installiert – der Installateur muß zwischendurch mal ein anderes Rohrsystem aufsuchen –
dann wird am Leitungs-Ende ein Hahn aufgeschraubt und erst wenn dieser geöffnet wird, beginnt die Flüssigkeit zu fließen.

Der Stream ist also ein Mechanismus zur Verarbeitung und nicht zur Speicherung. Diese Erkenntnis ist essentiell! Der Stream
verhält sich damit ähnlich wie das Optional. Tatsächlich handelt es sich um einen Einweg-Mechanismus, der nach
Abschluß des Streams verbraucht ist und nicht wieder verwendet werden kann – für jede Verarbeitung muß daher ein
neues {{java|Stream}}-Objekt erzeugt werden. Spätestens hier endet die Rohrleitungs-Analogie...

Der Stream muß die Objekte bei der Verarbeitung nicht notwendigerweise verändern, auch "rein untersuchende" Operationen, wie das Suchen von
Objekten mit bestimmten Eigenschaften läßt sich mit Streams sehr übersichtlich und effizient durchführen.
Aber genug der Theorie, schauen wir uns die drei Schritte zum Aufbau eines Streams an ein paar – mehr oder
minder – praktischen Beispiel an. Wir betrachten die drei genannten Schritte und lernen verschiedene Methoden
kennen, die zu diesem Schritt gehören.

== Schritt 1: Streams erzeugen ==
Betrachten wir zunächst die Erzeugung des Streams. Der typische Anwendungsfall beginnt mit einer Sammlung von
Objekten die irgendwo im Speicher herumliegen und verarbeitet werden möchten. Java bietet einige Möglichkeiten
an um einen Stream zu erzeugen, der aus einem Haufen von Objekten einen Strom formt.

Im einfachsten Fall hat man eine Liste von Literalen. Hier bietet sich die statische Methode {{java|Stream.of}}
aus dem {{java|Stream}}-Interfaces an:
{{java|code=Stream<String> stream = Stream.of("This", "is", "a", "test");}}
Man kann die gleiche (überladene) Methode auch für klassische Java-Arrays verwenden:
{{java|code=
String[] liste = {"This", "is", "a", "test"};
Stream<String> stream = Stream.of(liste);
}}
{{java|Stream}} ist ein generisches Interface. Jeder Stream liefert Objekte genau eines Typs. Die Streams in unseren
Beispielen liefern – der Einfachheit halber – Strings, aber selbstverständlich ist jeder Objekt-Typ erlaubt.

Ungleich häufiger ist der Wunsch, einen Stream aus einem Java-Collection-Objekt zu erzeugen. Hier erzeugen wir
zur Demonstration erst ein {{java|List}}-Objekt aus einer Literal-Liste und erzeugen dann einen Stream aus der Liste:
{{java|code=List<String> liste = Arrays.asList("This", "is", "a", "test");
Stream<String> stream = liste.stream();}}
In diesem Falle brauchen wir keine Hilfsfunktion, sondern erzeugen den Stream mit der Methode {{java|stream()}} direkt
aus dem {{java|List}}-Objekt. Ein Konzept, das man sehr gut auch für eigene Datenstrukturen verwenden kann um eine
Verarbeitung des Inhalts ohne Kenntnis der internen Struktur zu ermöglichen.
Nach dem gleichen Muster lassen sich auch aus Datei-Inhalten Streams erzeugen:
{{java|code=Stream<String> stream = Files.lines(Paths.get(fileName)));}}
Hier wird aus einer Text-Datei ein Stream von Strings erzeugt. Jeder String enthält den Text eine Zeile der Datei.
Weitere Möglichkeiten bieten Iteratoren und Generator-Funktionen, auf die hier nicht weiter eingegangen wird.
Auch die Möglichkeit, Streams zusammenzuführen oder aus einem Stream von {{java|List}}-Objekten einen Stream der
darin enthaltenen Objekte zu machen wird hier nicht näher erläutert. Es sei nur gesagt, daß da noch einiges zu
entdecken ist...

== Schritt 2: Die Verarbeitung ==
Nachdem der Stream erzeugt ist, muß definiert werden, was mit dem Objekt-Strom passieren soll der später
hindurchrauscht. Das {{java|Stream}}-Interface bietet dazu eine Reihe von Methoden. Man kann sich diese Methoden
vorstellen als Ventile im Rohr. Vorne kommt ein Strom von Objekten hinein und hinten fließt ein Strom von
Objekten wieder hinaus. Der Typ der Objekte kann, muß dabei aber nicht verändert werden. Ändert sich dabei der
Typ der Objekte, ändert sich auch der Typ des {{java|Stream}}-Objekts. Eclipse ist dabei sehr hilfreich, den Überblick zu
behalten, mit welchem Typ man gerade arbeitet...

Da wir mit Java-8 arbeiten, verwenden wir natürlich [[Lambdas in Java | λ-Ausdrücke]] um die zu verwendende Funktion zu
spezifizieren. Genau diese Möglichkeit macht die Streams zu einem extrem flexiblen und vielfältigen Mechanismus.
Die Auswahl an Stream-Methoden ist nicht erschöpfend und soll nur einen Eindruck geben von den verschiedenen
Möglichkeiten die die Verarbeitung hat.

=== Objekte betrachten: filter() ===
Der vielleicht einfachste Use Case ist die Anwendung eines Filters. Seine Aufgabe ist es, Objekte des Stroms
durchzulassen oder herauszufiltern (und fallen zu lassen). Für die Angabe der Filterbedingung verwenden wir einen
λ-Ausdruck der das Interface {{java|Predicate}} implementiert. {{java|Predicate}} definiert eine Funktion, die ein Objekt vom Typ
des Eingabe-Stroms als Argument nimmt und als Ergebnis {{java|true}} oder {{java|false}} liefert. Nur Objekte, die die Bedingung
des Prädikats erfüllen werden durchgelassen. Als Beispiel bauen wir uns wieder ein {{java|List}}-Objekt, erzeugen einen
Stream und filtern alle {{java|null}}-Werte heraus:
{{java|code=List<String> liste = Arrays.asList("This", "is", "a", null, "test");
Stream<String> stream = liste.stream().filter(x -> x != null);}}
Es entsteht dabei wieder ein Strom gleichen Typs (hier {{java|String}}), der gegebenenfalls weniger Objekte enthält als der
ursprüngliche Strom, aber garantiert keine neuen Objekte. Durch Hintereinanderschalten lassen sich Filter beliebig verketten:
{{java|code=Stream<String> stream = liste.stream().filter(x -> x != null).filter(x -> x.length() > 5);}}
Leider gibt es kein "negatives" Äquivalent zur {{java|filter}}-Methode, also eine Methode die diejenigen Objekte fallen
läßt, die das Prädikat erfüllen. Um das zu erreichen, muß man die {{java|filter}}-Methode mit einem ein entsprechenden,
negierten Prädikat verwenden.

=== Objekte manipulieren: map() ===
Die mächtigste Funktion ist zweifellos {{java|map()}}. Sie erlaubt die Anwendung einer Funktion, die ein Objekt des
Eingangsstroms als Parameter nimmt und ein beliebiges Objekt als Ergebnis liefert. Damit kann man die Objekte
eines Streams verändern oder umwandeln. Ändert sich der Typ des Objekts durch die Anwendung der Funktion,
ändert sich damit auch der Typ des Ausgabe-Stroms. Nehmen wir wieder einen {{java|String}}-Stream, und "trimmen" die
Strings beim Durchlauf:
{{java|code=List<String> liste = Arrays.asList("This ", " is ", " a ", null, " test");
Stream<String> stream = liste.stream().map(String::trim);}}
Richtig, das wird schiefgehen und in einer Null-Pointer-Exception enden. Der Fehler wird aber noch nicht an ''dieser'' Stelle
auftreten, sondern erst, wenn der Stream im dritten Schritt abgeschlossen wird. Erst dann wird die
Verarbeitung gestartet, und die Objekte strömen los. Bevor wir {{java|trim()}} anwenden können, sollten wir also die {{java|null}}-
Werte herausfiltern. Dazu können wir die Methoden {{java|map()}} und {{java|filter()}} miteinander kombinieren.
Filtern wir also zuerst die {{java|null}}-Werte heraus; Java-8 bietet extra für diesen Fall eine convenience-Methode
in der {{java|Objects}}-Klasse:
{{java|code=List<String> liste = Arrays.asList("This ", " is ", " a ", null, " test");
Stream<String> stream = liste.stream().filter(Objects::nonNull).map(String::trim);}}
Bei der gezeigten Anwendung von {{java|map()}} bleibt der Typ des Streams unverändert, da {{java|String::trim}} ebenfalls Strings
liefert. Mit der String-Methode {{java|length()}} können wir zu jedem String dessen Länge bestimmen und so einen
{{java|integer}}-Stream erzeugen. Das Autoboxing von Java erzeugt dabei automatisch {{java|Integer}}-Objekte:
{{java|code=List<String> liste = Arrays.asList("This ", " is ", " a ", null, " test");
Stream<Integer> stream = liste.stream().filter(Objects::nonNull).map(String::length);}}
Es sei darauf hingewiesen, daß Java-8 eigene Implementierungen für Zahlen-Streams anbietet ({{java|IntStream}},
{{java|LongStream}} etc.) die wesentlich effizienter arbeiten. Das Beispiel sollte nur illustrieren, wie sich durch Anwendung
einer Funktion, die den Typ ändert, auch der Typ des Streams ändert. Die Klasse {{java|Integer}} im obigen Beispiel steht
stellvertretend für jede beliebige andere Klasse. Mit der Methode {{java|mapInt}} läßt sich zum Beispiel
ein {{java|IntStream}} erzeugen:
{{java|code=List<String> liste = Arrays.asList("This ", " is ", " a ", null, " test");
IntStream stream = liste.stream().filter(Objects::nonNull).mapToInt(String::length);}}
An dieser Stelle macht sich der Unterschied zwischen funktionaler und objektorientierter Sichtweise bemerkbar:
Der Methodenaufruf {{java|.filter(Objects::nonNull)}} liefert ein Objekt vom Typ {{java|Stream<String>}} das vom
Aufruf {{java|.map(String::length)}} in ein Objekt vom Typ {{java|Stream<Integer>}} umgewandelt wird. Technisch entsteht
dabei natürlich ein neues Objekt, aber es hilft dem Verständnis wenn man sich vorstellt, als gäbe es nur ein {{java|Stream}}-Objekt
das nach dem Aufruf von {{java|.filter(Objects::nonNull)}} einen {{java|String}}-Strom liefert und nach dem Aufruf
von {{java|.map(String::length)}} einen {{java|Integer}}-Strom. Oder übertragen auf die Rohrleitung: Das Leitungssystem (in
Analogie zum Stream-Objekt) liefert nach Aufstecken des ersten Ventils (dem non-null-filter) einen Strom von
Buchstabenketten und nach Aufstecken des zweiten Ventils (der length-map) einen Strom von Zahlen.
Der folgende JUnit-Schnipsel führt zu einer Exception im Assert:
{{java|code=List<String> liste = Arrays.asList("This ", " is ", " a ", null, " test");
Stream<String> stream = liste.stream();
Stream<String> streamNotNull = stream.map(String::trim);
Assert.assertEquals(5, stream.count());}}

=== In alle Objekte des Strom hineinschauen: sorted() und distinct() ===
Wer Listen hat, hat auch bedarf nach Reihenfolge. Das {{java|Stream}}-Interface hat dafür zwei Methoden im Angebot.
Die Methode {{java|sorted()}} liefert einen Strom, der die Objekte im Eingangs-Strom nach der "natürlichen" Ordnung sortiert.

Die Objekte des Eingangs-Stroms müssen dafür das Interface {{java|Comparable}} implementieren. Alternativ
kann man der Methode auch ein {{java|Comparator}}-Objekt übergeben, das Objekte des Eingabe-Typs vergleicht.

Analog zum gleichnamigen SQL-statement vergleicht die Methode {{java|distinct()}} die Objekte des Eingangs-Stroms
mithilfe der Methode {{java|equals()}} und sorgt dafür, daß sich alle Objekte des Ausgangs-Stroms unterscheiden. Für
sortierte Ströme wird immer das erste Element durchgelassen, für unsortierte Ströme ist das nicht garantiert.

=== Alle Objekte es Stroms betrachten: skip() und limit() ===
Ähnlich wie die {{java|filter}}-Methode dienen diese beiden Methoden dazu, Objekte aus dem Strom auszuschließen, im
Gegensatz zum Filter schauen diese Methoden jedoch nicht in die Objekte hinein.

Die Methode {{java|skip()}} hat einen Parameter vom Typ long und überspringt Objekte im Strom.

{{java|skip(5)}} hat zur Wirkung, daß die nächsten fünf Objekte des Eingabe-Stroms herausgefiltert werden und nicht
mehr im Ausgabe-Strom auftauchen.

Die Methode {{java|limit()}} hat ebenfalls einen Parameter vom Typ long und beschränkt die Zahl der Objekte im
Ausgabe-Strom.

{{java|limit(10)}} hat zur Wirkung, daß der Ausgabe-Strom maximal 10 Objekte enthält.

=== Parallelisierung: parallel() und sequential() ===
Streams wurden eingeführt um die parallele Verarbeitung von Objekten zu ermöglichen. Mit der Methode
{{java|parallel()}} läßt sich aus jedem Strom eine Menge – potentiell parallel laufender – Ströme machen. Alle Objekte in
allen parallelen Strömen werden dann in der gleichen Art und Weise – so wie es der Stream definiert –
verarbeitet. Wenn die ausführende JVM eine Möglichkeit sieht, wird sie versuchen die Verarbeitung mit
verschiedenen Threads zu parallelisieren. Mit der Methode {{java|sequential()}} lassen sich die parallelen Ströme wieder
zusammenführen:
{{java|code=Stream<String> stream =
liste.stream().parallel().filter(Objects::nonNull).map(String::trim).sequential();}}
Welcher Strom dann welche Objekte zur Verarbeitung erhält ist nicht vorhersagbar. Die λ-Ausdrücke, die {{java|.map}}
verwendet, sollten daher immer zustandsfrei sein und keinen Bezug zu anderen Objekten haben. Und bevor man
ein Objekt verändert, sollte man überlegen, ob es nicht besser ist statt dessen ein neues Objekt zu erzeugen – so
wie {{java|String::trim}} es tatsächlich auch tut.
Streams entstammen der funktionalen Welt und funktionieren daher am besten mit seiteneffektfreien Funktionen
und mit unveränderlichen Objekten.

== Schritt 3: Abschluß ==
Nachdem wir nun allerhand Schabernack mit den Objekten des Stroms getrieben haben, ist es an der Zeit den
Stream zu schließen und die Früchte unserer Arbeit zu ernten. Die meisten Abschluß-Funktionen des {{java|Stream}}-
Interface liefern ein einzelnes Ergebnis das in ein {{java|Optional}} verpackt ist. Das bietet uns die Möglichkeit mit leeren
Streams und ungültigen Ergebnissen umzugehen.

Wie bereits erwähnt läuft der Stream mit Aufruf der Abschluß-Methode los und die (komplette) Verarbeitung wird durchgeführt.

=== Quantoren: Alle oder Keins ===
Mit den Methoden {{java|anyMatch()}} und {{java|allMatch()}} kann geprüft werden, ob der Strom ein Objekt mit einer
bestimmten Eigenschaft enthält oder nicht. Sie arbeiten "lazy", das heißt daß nur solange Objekte des Stroms
ausgewertet werden bis das Ergebnis feststeht. Auch das ist beim Design der verwendeten λ-Ausdrücke zu beachten.
Enthält ein λ-Ausdruck Seiteneffekte, muß man berücksichtigen daß diese nicht für jedes Objekt im Strom zur Geltung
kommen. Das folgende Beispiel prüft, ob die Liste (mindestens) einen String der Länge 5 enthält:
{{java|code=boolean fuenfExists = liste.stream().filter(Objects::nonNull).map(String::length).anyMatch(x -> x == 5);}}
Dieses Beispiel soll prüfen, ob alle Strings in der Liste ungleich {{java|null}} sind.
{{java|code=boolean alleGesetzt = liste.stream().allMatch(Objects::nonNull);}}
Statt "alle Objekte sind nicht null" kann man auch sagen "kein Objekt ist null". Die passende dafür Methode ist
{{java|noneMatch()}}. Mit der Methode {{java|Objects::isNull}}, kann man also alternativ schreiben:
{{java|code=boolean alleGesetzt = liste.stream().noneMatch(Objects::isNull);}}

=== Suchfunktionen: Wenn ja, welches? ===
Wenn das schiere Wissen um die Existenz nicht reicht, kann man sich auch das erste oder irgendein Objekt aus dem
Strom geben lassen. Die Methode {{java|findAny()}} liefert irgendein Objekt und {{java|findFirst()}} liefert das erste Objekt
das den Stream vollständig passiert hat. Hier suchen wir den ersten String, der nicht {{java|null}} ist:
{{java|code=Optional<String> firstOne = liste.stream().filter(Objects::nonNull).findFirst();}}
Da der Strom kein solches Objekt erhalten muß, ist das Ergebnis in ein {{java|Optional}} verpackt. Die Methode {{java|findAny()}}
tut im Prinzip das Gleiche, liefert aber nicht unbedingt das erste Objekt im Strom, das die gegebenen Eigenschaften
erfüllt. Der Unterschied der beiden Methoden wird erst bei parallelen Strömen spürbar, wenn die Reihenfolge der
Verarbeitung nicht mehr vorhersagbar ist.

Für nicht-parallele Streams liefern beide Methoden das gleiche Ergebnis.
Man tut aber gut daran, für den jeweiligen Zweck die entsprechende Methode zu verwenden.
Erstens wird dadurch dei Intention des Programmierers dokumentiert und zweitens ist die Implementierung
für Parallelisierung gewappnet; falls das eines Tages gewünscht sein sollte.

=== Mach' was mit: Verarbeitung der Objekte ===
''Ein'' Use Case für Streams ist die Verarbeitung einer Menge von Objekten. Hierfür dient die Methode {{java|foreach()}}. Als
Parameter dient ein λ-Ausdruck das das Interface {{java|Consumer{{java| implementiert. Es nimmt ein Objekt des Eingabe-Stroms
und "liefert" {{java|void}} – also gar nichts. Das Objekt verschwindet zwar nicht, wird aber auch nicht weitergereicht, die
Verarbeitung endet hier.

Im Beispiel werden alle Strings die nicht {{java|null}} sind auf der System-Ausgabe ausgegeben:
{{java|code=liste.stream().filter(Objects::nonNull).forEach(System.out::print);}}

=== Das Ergebnis sammeln: collect und count ===
Streams sind sehr gut dafür geeignet, um aus Listen neue Listen zu generieren. Dazu muß man den Ergebnis-Strom
auffangen und in ein passendes Gefäß füllen. Die Möglichkeiten, die Java hier bietet sind vielfältig und einen
eigenen Beitrag wert. Die einfachste Variante ist die Verwendung der Klasse {{java|Collectors}} um den Ergebnis-Strom in
ein {{java|Collection}}-Objekt zu füllen. Im Beispiel werden zunächst alle {{java|null}}-Werte aus dem Strom entfernt, das
Ergebnis sortiert und schließlich in ein neues {{java|List}}-Objekt gefüllt:
{{java|code=List<String> liste = Arrays.asList("This", "is", "a", "test");
List<String> sort = liste.stream().filter(Objects::nonNull).sorted().collect(Collectors.toList());}}
Die Methode {{java|Collectors.toList()}} entscheidet dabei, welche {{java|List}}-Implementierung verwendet wird.

Eine weitere, einfache Anwendung ist das Zählen von Objekten. Hier zählen wir alle Objekte im Strom, die nicht {{java|null}} sind:
{{java|code=long anzahl = liste.stream().filter(Objects::nonNull).count();}}
Ein {{java|Optional}} brauchen wir diesmal nicht. Wenn der Ausgabe-Strom leer ist, ist das Ergebnis 0, also "zero" und nicht "null".
Im Grunde genommen ist das ein Spezialfall eines Collectors, der die Liste auf ein einzelnes Objekt – in diesem Falle eine Zahl – reduziert.

Es gibt weitere, komplexere Kollektoren, aber für den Anfang mögen diese einfachen Beispiele genügen.
Diese Kombination von Verarbeitung einer Liste und Zusammenführen der Ergebnisse ist auch als "map-reduce"-Pattern bekannt.
Weitergehende Betrachtungen zur collect-Methode finden sich hier: [[Streams: Ergebnis sammeln]].

== Fazit ==
Der Beitrag konnte nur einen Einblick bieten, vor allem die Themen "Parallelisierung" und "Kollektoren" konnten nur
angerissen werden,
aber vielleicht wird hier schon deutlich, welches Potential in den Streams steckt. Java-9 erweitert das Konzept
zudem in Richtung "reactive", was neue Möglichkeiten bietet – Streams gehört (wenigstens zu einem Teil) die Zukunft.
Zum Schluß noch der direkte Vergleich zwischen einer klassischen und einer Stream-Lösung.
Eine Methode soll uns dafür mitteilen, wieviele {{java|null}}-Werte eine String-Liste enthält.

Mit einer "enhanced for"-Schleife sieht das so aus:
{{java|code=
private long count(List<String> liste) {
int result = 0;
for(String s : liste) {
if (s != null) {
result++;
}
}
return result;
}
}}
Mit Streams sieht das so aus:
{{java|code=
private long count(List<String> liste) {
return liste.stream().filter(Objects::nonNull).count();
}
}}
Der Leser entscheide selbst, was schöner ist.

Streams: Java 8 Streams Einführung - Versionsgeschichte

Ullrich: /* Mach' was mit: Verarbeitung der Objekte */

Ullrich: Ullrich verschob die Seite Java 8 Streams Einführung nach Streams: Java 8 Streams Einführung

Ullrich: Ullrich verschob die Seite In Java 8 Streams Einführung nach Java 8 Streams Einführung, ohne dabei eine Weiterleitung anzulegen

Ullrich: Ullrich verschob die Seite Einführung in Java 8 Streams nach In Java 8 Streams Einführung, ohne dabei eine Weiterleitung anzulegen

Ullrich: Ullrich verschob die Seite Editing Einführung in Java 8 Streams nach Einführung in Java 8 Streams, ohne dabei eine Weiterleitung anzulegen

Ullrich am 29. Juli 2020 um 19:15 Uhr

Ullrich: Die Seite wurde neu angelegt: „Category:Java Man kann Java-8-Streams als ein Konzept beschreiben, mit dem eine Menge von Objekten in gleichartiger Weise verarbeitet werden kann. Die Vera…“

← Nächstältere Version	Version vom 9. März 2023, 17:39 Uhr
(kein Unterschied)

← Nächstältere Version	Version vom 21. April 2021, 20:36 Uhr
(kein Unterschied)

← Nächstältere Version	Version vom 10. April 2021, 15:19 Uhr
(kein Unterschied)