17.6    Intermediäre Operationen 

Alle terminalen Operationen führen zu keinem neuen veränderten Stream, sondern beenden den aktuellen Stream. Anders sieht das bei intermediären Operationen aus: Sie verändern den Stream, indem sie etwa Elemente herausnehmen, auf andere Werte und Typen abbilden oder sortieren. Jede der intermediären Methoden liefert ein neues Stream-Objekt. Das haben wir in den ersten Schreibweisen durch die Konkatenation etwas verschleiert, aber vollständig sieht es so aus:

Stream<Object> a =

 Stream.of(" ",'3',null,"2",1,"");

Stream<Object> b = a.filter(Objects::nonNull);

Stream<String> c = b.map(Objects::toString );

Stream<String> d = c.map(String::trim);

Stream<String> e = d.filter(s -> !s.isEmpty());

Stream<Integer> f = e.map(Integer::parseInt);

Stream<Integer> g = f.sorted();

g.forEach(System.out::println);

Stream

 .of(" ",'3',null,"2",1,"")

 .filter(Objects::nonNull)

 .map(Objects::toString)

 .map(String::trim)

 .filter(s -> ! s.isEmpty())

 .map(Integer::parseInt)

 .sorted()

 .forEach(System.out::println);

Tabelle 17.4    Ausführliche und kompakte Schreibweise im Vergleich

 

17.6.1    Element-Vorschau 

Eine einfache intermediäre Operation ist peek(…). Sie darf sich das aktuelle Element während des Durchlaufs anschauen.

interface java.util.stream.Stream<T>

extends BaseStream<T,Stream<T>>

• Stream<T> peek(Consumer<? super T> action)

System.out.println( Stream.of( 9, 4, 3 )

                          .peek( System.out::println ) // 9 4 3

                          .sorted()

                          .peek( System.out::println ) // 3 4 9

                          .collect( Collectors.toList() ) );

 

17.6.2    Filtern von Elementen 

Eine der wichtigsten Stream-Methoden ist filter(…): Sie liefert alle Elemente im Stream, die einem Kriterium genügen, und ignoriert alle anderen, die nicht diesem Kriterium genügen.

interface java.util.stream.Stream<T>

extends BaseStream<T,Stream<T>>

• Stream<T> filter(Predicate<? super T> predicate)

Stream.of( "Moor", "Aha", "Meister" )

      .filter( Pattern.compile( "[aeiou]{2}" ).asPredicate() )

      .forEach( System.out::println );      // Moor Meister

 

17.6.3    Statusbehaftete intermediäre Operationen 

Die allermeisten intermediären Operationen können Elemente direkt während des Durchlaufs bewerten und verändern, sodass keine speicherintensive Zwischenspeicherung nötig ist. Einige intermediäre Operationen haben jedoch einen Status. Dazu zählen:

• limit(long): begrenzt den Strom auf eine gewisse Anzahl maximaler Elemente.

• skip(long): überspringt eine Anzahl Elemente.

• distinct(): löscht alle doppelten Elemente.

• sorted(…): sortiert den Strom.

interface java.util.stream.Stream<T>

extends BaseStream<T,Stream<T>>

• Stream<T> limit(long maxSize)

• Stream<T> skip(long n)

• Stream<T> distinct()

• Stream<T> sorted()

• Stream<T> sorted(Comparator<? super T> comparator)

String longest = Stream.of( "Autos", "können", "nicht", "versaut", "genug", "sein" )

       .sorted( Comparator.comparing( String::length ).reversed() )

       .findFirst().get();

System.out.println( longest ); // versaut

String longest = …

    .max( Comparator.comparing( String::length ) )

    .get();

List<String> list = Pattern.compile( " " ).splitAsStream( "Pu Po Aha La" )

    .map( s -> s.substring(0, 1) )

    .peek( System.out::println ) // P P A L

    .distinct()                  // \/\/\/

    .peek( System.out::println ) //  P A L

    .collect( Collectors.toList() );

System.out.print( list );                       // [P, A, L]

 

17.6.4    Präfix-Operation 

Unter einem Präfix verstehen wir eine Teilfolge eines Streams, die beim ersten Element beginnt. Wir können mit limit(long) selbst ein Präfix generieren, doch im Allgemeinen geht es darum, eine Bedingung zu haben, die alle Elemente eines Präfix-Streams erfüllen müssen, und den Stream zu beenden, wenn die Bedingung für ein Element nicht mehr gilt. Java 9 deklariert dafür zwei neue Methoden, takeWhile(…) und dropWhile(…):

• default Stream<T> takeWhile(Predicate<? super T> predicate)

• default Stream<T> dropWhile(Predicate<? super T> predicate)

Die deutsche Übersetzung von takeWhile(…) wäre »nimm, solange predicate gilt« und dropWhile(…) »lass fallen, solange predicate gilt«.

new Scanner( "Dann twitterte Trump am 7. Nov. 2012: "

           + "'It's freezing and snowing in New York--we need global warming!'" )

  .useDelimiter( "\\P{Alpha}+" ).tokens()

  .takeWhile( s -> !s.equalsIgnoreCase( "trump" ) )

  .forEach( System.out::println );  // Dann twitterte

}

Stream.of( 1, 2, -1, 3, 4, -1, 5, 6 )

      .dropWhile( i -> i > 0 )         // !(i>0), also i<=0 wird übersprungen

      .forEach( System.out::println ); // -1 3 4 -1 5 6

Erfüllt schon bei takeWhile(…) das erste Element nicht das Prädikat, so ist der Stream leer. takeWhile(…) und dropWhile(…) können zusammen verwendet werden: So liefert Stream.of( 1, 2, -1, 3, 4, -1, 5, 6 ).dropWhile( i -> i > 0 ).skip( 1 ).takeWhile( i -> i > 0 ).forEach( System.out::println ); die Ausgaben 3 4.

 

17.6.5    Abbildungen 

Die Fähigkeit, Elemente im Strom auf neue Elemente abzubilden ist eines der mächtigsten Werkzeuge der Stream-API. Zu unterscheiden sind drei Typen von Abbildungsmethoden:

• Die einfachste Variante ist map(Function). Die Funktion bekommt das Stromelement als Argument und liefert ein Ergebnis, das dann in den Strom kommt. Hierbei kann sich der Typ ändern, wenn die Funktion nicht den gleichen Typ gibt, wie sie nimmt. Die Funktion wird nach und nach auf jedem Element angewendet, und die Reihenfolge ergibt sich aus der Ordnung des Stroms.

• Die drei Methoden mapTo[Int|Long|Double]([int|long|double]Function) arbeiten wie map(Function), nur liefern die Funktionen einen primitiven Wert, und das Ergebnis ist ein primitiver Stream.

• flatMapXXX(XXXFunction)-Methoden ersetzen ebenfalls Elemente im Stream, mit dem Unterschied, dass die Funktionen alle selbst Stream-Objekte liefern, deren Elemente dann in den Ergebnisstrom gesetzt werden. Der Begriff flat (engl. für »flach«) kommt daher, dass die »inneren« Streams nicht selbst alle als Elemente in den Ursprungs-Stream kommen (sozusagen ein Stream<Stream>), sondern »flachgeklopft«werden. Anwendungsbeispiele sind in der Regel Szenarien wie »n Spieler assoziieren m Gegenstände, gesucht ist ein Strom aller Gegenstände aller Spieler«. Die Funktion kann null liefern, wenn nichts in den Stream gelegt werden soll.

interface java.util.stream.Stream<T>

extends BaseStream<T,Stream<T>>

• <R> Stream<R> map(Function<? super T,? extends R> mapper)

• IntStream mapToInt(ToIntFunction<? super T> mapper)

• LongStream mapToLong(ToLongFunction<? super T> mapper)

• DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)

• <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

• IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)

• LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)

• DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)

String[] numbers = { "1", "2", "3" };

long[] parseInts = Stream.of( numbers ).mapToLong( Long::parseLong ).toArray();

Stream.of( Locale.getAvailableLocales() )

      .map( Locale::getCountry )

      .distinct()

      .forEach( System.out::println );

Stream.of( Locale.getAvailableLocales() )

      .flatMap( l -> Stream.of( DateFormatSymbols.getInstance( l ).getWeekdays() ) )

      .filter( s -> ! s.isEmpty() )

      .distinct()

      .forEach( System.out::println );

Stream<…> flatStream = Optional.ofNullable( result )

                               .map( Stream::of ).orElse( Stream.empty() );

Stream.of( Object.class, Thread.State.class, DayOfWeek.class )

      .flatMap( clazz -> Optional.ofNullable( clazz.getEnumConstants() )

                                 .map( Stream::of ).orElse( Stream.empty() ) )

      .forEach( System.out::println );

Stream.of( null, new Point( 1, 2 ), null, new Point( 3, 4 ) )

      .flatMap( q -> Stream.of( q.x, q.y ) )

      .forEach( System.out::println );

Stream.of( null, new Point( 1, 2 ), null, new Point( 3, 4 ) )

      .flatMap( p -> Stream.ofNullable( p ).flatMap( q -> Stream.of( q.x, q.y ) ) )

      .forEach( System.out::println );