Streams: Java 8 Streams Einführung
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 Stream-Objekts besteht aus drei Schritten:
Im ersten Schritt muß zunächst ein Stream-Objekt erzeugt werden, mit dem die Objekte verarbeitet werden
können. Diesem 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 Stream-Objekts entscheiden, welche
Objekte man durch die Rohrleitung schickt. Glücklicherweise ist die Erzeugung eines 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):
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 count()). Man muß die Methoden daher nicht unmittelbar
hintereinenader ausführen, sondern kann – wenn erforderlich – die Konstruktion des 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 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 Stream.of
aus dem Stream-Interfaces an:
Stream<String> stream = Stream.of("This", "is", "a", "test");
Man kann die gleiche (überladene) Methode auch für klassische Java-Arrays verwenden:
String[] liste = {"This", "is", "a", "test"};
Stream<String> stream = Stream.of(liste);
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 List-Objekt aus einer Literal-Liste und erzeugen dann einen Stream aus der Liste:
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 stream() direkt
aus dem 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:
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 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 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 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 λ-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 Predicate implementiert. Predicate definiert eine Funktion, die ein Objekt vom Typ
des Eingabe-Stroms als Argument nimmt und als Ergebnis true oder false liefert. Nur Objekte, die die Bedingung
des Prädikats erfüllen werden durchgelassen. Als Beispiel bauen wir uns wieder ein List-Objekt, erzeugen einen
Stream und filtern alle null-Werte heraus:
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 String), der gegebenenfalls weniger Objekte enthält als der
ursprüngliche Strom, aber garantiert keine neuen Objekte. Durch Hintereinanderschalten lassen sich Filter beliebig verketten:
Stream<String> stream = liste.stream().filter(x -> x != null).filter(x -> x.length() > 5);
Leider gibt es kein "negatives" Äquivalent zur filter-Methode, also eine Methode die diejenigen Objekte fallen
läßt, die das Prädikat erfüllen. Um das zu erreichen, muß man die filter-Methode mit einem ein entsprechenden,
negierten Prädikat verwenden.
Objekte manipulieren: map()
Die mächtigste Funktion ist zweifellos 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 String-Stream, und "trimmen" die
Strings beim Durchlauf:
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 trim() anwenden können, sollten wir also die null-
Werte herausfiltern. Dazu können wir die Methoden map() und filter() miteinander kombinieren.
Filtern wir also zuerst die null-Werte heraus; Java-8 bietet extra für diesen Fall eine convenience-Methode
in der Objects-Klasse:
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 map() bleibt der Typ des Streams unverändert, da String::trim ebenfalls Strings
liefert. Mit der String-Methode length() können wir zu jedem String dessen Länge bestimmen und so einen
integer-Stream erzeugen. Das Autoboxing von Java erzeugt dabei automatisch Integer-Objekte:
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 (IntStream,
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 Integer im obigen Beispiel steht
stellvertretend für jede beliebige andere Klasse. Mit der Methode mapInt läßt sich zum Beispiel
ein IntStream erzeugen:
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 .filter(Objects::nonNull) liefert ein Objekt vom Typ Stream<String> das vom
Aufruf .map(String::length) in ein Objekt vom Typ 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 Stream-Objekt
das nach dem Aufruf von .filter(Objects::nonNull) einen String-Strom liefert und nach dem Aufruf
von .map(String::length) einen 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:
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 Stream-Interface hat dafür zwei Methoden im Angebot.
Die Methode 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 Comparable implementieren. Alternativ
kann man der Methode auch ein Comparator-Objekt übergeben, das Objekte des Eingabe-Typs vergleicht.
Analog zum gleichnamigen SQL-statement vergleicht die Methode distinct() die Objekte des Eingangs-Stroms
mithilfe der Methode 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 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 skip() hat einen Parameter vom Typ long und überspringt Objekte im Strom.
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 limit() hat ebenfalls einen Parameter vom Typ long und beschränkt die Zahl der Objekte im
Ausgabe-Strom.
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
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 sequential() lassen sich die parallelen Ströme wieder
zusammenführen:
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 .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 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 Stream-
Interface liefern ein einzelnes Ergebnis das in ein 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 anyMatch() und 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:
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 null sind.
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
noneMatch(). Mit der Methode Objects::isNull, kann man also alternativ schreiben:
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 findAny() liefert irgendein Objekt und findFirst() liefert das erste Objekt
das den Stream vollständig passiert hat. Hier suchen wir den ersten String, der nicht null ist:
Optional<String> firstOne = liste.stream().filter(Objects::nonNull).findFirst();
Da der Strom kein solches Objekt erhalten muß, ist das Ergebnis in ein Optional verpackt. Die Methode 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 foreach(). Als
Parameter dient ein λ-Ausdruck das das Interface {{java|Consumer{{java| implementiert. Es nimmt ein Objekt des Eingabe-Stroms
und "liefert" 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 null sind auf der System-Ausgabe ausgegeben:
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 Collectors um den Ergebnis-Strom in
ein Collection-Objekt zu füllen. Im Beispiel werden zunächst alle null-Werte aus dem Strom entfernt, das
Ergebnis sortiert und schließlich in ein neues List-Objekt gefüllt:
List<String> liste = Arrays.asList("This", "is", "a", "test");
List<String> sort = liste.stream().filter(Objects::nonNull).sorted().collect(Collectors.toList());
Die Methode Collectors.toList() entscheidet dabei, welche List-Implementierung verwendet wird.
Eine weitere, einfache Anwendung ist das Zählen von Objekten. Hier zählen wir alle Objekte im Strom, die nicht null sind:
long anzahl = liste.stream().filter(Objects::nonNull).count();
Ein 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 null-Werte eine String-Liste enthält.
Mit einer "enhanced for"-Schleife sieht das so aus:
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:
private long count(List<String> liste) {
return liste.stream().filter(Objects::nonNull).count();
}
Der Leser entscheide selbst, was schöner ist.