Nachdem wir uns in Kapitel 1 damit beschäftigt haben, wie die Daten in die Streams gelangen und wie sie wieder zu entnehmen sind, werden wir uns jetzt mit der Datentransformation beschäftigen. Es stehen einem unter anderem drei Basismethoden – forEach, match und find – zur Verfügung, mit denen man schnell und einfach die ersten Versuche unternehmen kann.
2.1 forEach – ein Lambda für jedes Element
Die Methode forEach(<lambda>) macht eigentlich genau das, was man vermutet. Sie wendet das als Argument übergebene Lambda auf jedes einzelne Element des Streams an. Diese Methode ist auch bei Iterable, List, Map und einigen anderen Klassen/Interfaces zu finden, was erfreulicherweise zu kürzeren sprachlichen Konstrukten führt. Listing 2.1 zeigt die Iteration in Pre JDK 8 Notation, Listing 2.2 unter der Verwendung von forEach(<lambda>). In Listing 2.2 sind eine lange und zwei kurze Versionen zu sehen. Die lange Version verwendet die volle Notation inklusive der geschwungenen Klammern. Die beiden kurzen Versionen verwenden die Notation, um auf statische Methoden zuzugreifen.
final List<Pair> generateDemoValues = new
PairListGenerator(){}.generateDemoValues();
//pre JDK8
for (final Pair generateDemoValue : generateDemoValues) {
System.out.println(generateDemoValue);
}Listing 2.1: Pre JDK 8 Notation
//long version
generateDemoValues.stream()
.forEach(v -> { System.out.println(v) });
//short version - seriel
generateDemoValues.stream()
.forEach(System.out::println);
//short version - parallel
generateDemoValues.parallelStream()
.forEach(System.out::println);Listing 2.2: JDK 8 Notation
In Listing 2.2 ist ein kleiner, aber feiner Unterschied in den beiden kurzen Versionen. Die erste Definition geht auf einen seriellen Stream zurück, die zweite auf einen parallelen Stream. Bei beiden ist sichergestellt, dass die übergebene Methodenreferenz nur einmal auf jedes Element angewendet wird. Nicht sichergestellt ist jedoch die Reihenfolge, in der die einzelnen Elemente abgearbeitet werden, wenn es sich um parallele Streams handelt. Ist die Reihenfolge von Bedeutung, muss die Methode forEachOrdered(<lambda>) verwendet werden. Hier wird bei der Abarbeitung die Reihenfolge, die in der Datenquelle vorliegt, eingehalten. Das sollte nur verwendet werden, wenn es zwingend notwendig ist. Was hier allerdings auf den ersten Blick nicht ersichtlich ist, dass ein NotNullCheck durchgeführt wird und im Falle von null mit einer NullPointerException quittiert wird. Jedes Element wird durch die consumer.accept-Methode konsumiert. (Listing 2.3)
//class - ReferencePipeline
@Override
public void forEach(Consumer<? super P_OUT> action) {
evaluate(ForEachOps.makeRef(action, false));
}
//class - AbstractPipeline
final <R> R evaluate(TerminalOp<E_OUT, R> terminalOp) {
assert getOutputShape() == terminalOp.inputShape();
if (linkedOrConsumed)
throw new IllegalStateException(MSG_STREAM_LINKED);
linkedOrConsumed = true;
return isParallel()
? terminalOp.evaluateParallel(this,
sourceSpliterator(terminalOp.getOpFlags()))
: terminalOp.evaluateSequential(this,
sourceSpliterator(terminalOp.getOpFlags()));
}
//class - ForEachOps
public static <T> TerminalOp<T, Void>
makeRef(Consumer<? super T> action, boolean ordered) {
Objects.requireNonNull(action); //throws NPE
return new ForEachOp.OfRef<>(action, ordered);
}
//class – ForEachOps. OfRef
static final class OfRef<T> extends ForEachOp<T> {
final Consumer<? super T> consumer;
//...
@Override
public void accept(T t) {
consumer.accept(t);
}
}Listing 2.3: forEach
Bei der Verwendung von forEach(<lambda>) ist...

