Zu den Neuerungen in Java 8 gehören Ansätze funktionaler Programmierung, Lambda-Ausdrücke, Stream-API, Bulk Operations on Collections, Filter-Map-Reduce und einiges mehr. Der folgende Text beschreibt nur einige Grundlagen. Weitergehende Informationen finden Sie zum Beispiel unter:

• Oracle: What's New in JDK 8
• Oracle: Java Tutorials, Oracle: Lambda Expressions
• OpenJDK Project Lambda, JSR 335
• Angelika Langer: Effective Java, Lambda Expressions, Angelika Langer: Lambda Tutorial
• Java SE 8 API, Functional Interfaces in java.util.function, Stream-API in java.util.stream

Inhalt

1. Funktionale Programmierung, Funktionen, Code-as-Data
   
2. Functional Interface Type, SAM Type
   
3. Lambda-Ausdrücke
   
4. Default-Methoden, interne Iterierung, Mehrfachvererbung
   
5. Streams und Bulk Operations on Collections
   
6. Filter-Map-Reduce
   
7. Filter-Map-Reduce mit paralleler Verarbeitung
   

Funktionale Programmierung, Funktionen, Code-as-Data

Java ist eine "imperative, objektorientierte Programmiersprache" und keine "funktionale Programmiersprache". Aber seit Version 8 werden in Java einige Aspekte der "funktionalen Programmierung" unterstützt.

"Funktionen" ähneln Methoden. Aber anders als Methoden werden Funktionen bei "funktionaler Programmierung" weitergereicht, beispielsweise als Argumente an Methoden oder als Return-Wert einer Methode. Dies wird manchmal als "Code-as-Data" bezeichnet.

Anders als "funktionale Sprachen" bietet Java keine "Funktionstypen". Trotzdem können Referenzen auf Funktionen weitergereicht werden.

Beim so genannten "Currying" können Funktionen auch manipuliert werden.

"Rein funktionale Sprachen" ("pure functional Language") wie beispielsweise Haskell sind zustandslos und Funktionen haben keinerlei Seiteneffekte. Sie ändern keine Daten, sondern können höchstens neue Daten returnieren. Das ist bei Java anders. Hier können Funktionen durchaus Daten ändern.

"Rein funktionale Programmierung" eignet sich ideal zur Parallelverarbeitung sowie für mathematische Aufgaben, und steht in dem Ruf, dass so erstellte Programme weniger Fehler enthalten sollen. Nachteilig ist, dass sich reale Objekte und Zustandsänderungen nur schwierig abbilden lassen, was die Programmierung realer Vorgänge und Geschäftsprozesse erschwert. Dies ist mit objektorientierter zustandsbehafteter Programmierung wesentlich leichter realisierbar.

Functional Interface Type, SAM Type

Interfaces mit einer einzigen abstrakten Methode heißen neuerdings "Functional Interface Types" oder auch "SAM Types". "SAM" steht für "Single Abstract Method". Solche Interfaces können mit der Annotation @FunctionalInterface versehen werden und haben für Lambdas eine besondere Bedeutung, da sie die einzigen Typen sind, die als "Target-Typing-Zieltypen" in Frage kommen.

Beispiele:
Predicate, Function, Consumer und alle weiteren Functional Interfaces in java.util.function,
sowie z.B. ActionListener, AutoCloseable, Callable, Comparable, Comparator, FileFilter, FilenameFilter, Iterable, Runnable u.s.w.

Lambda-Ausdrücke

Lambda-Ausdrücke (entsprechend JSR 335) stellen Funktionen dar, ohne Namen, ohne explizite Angabe des Return-Typs und ohne Deklaration von Exceptions.

Die allgemeine Syntax für einen Lambda-Ausdruck lautet:

( Parameterliste ) -> { Ausdruck oder Anweisungen }

Beispiel:

( File f ) -> { return f.isFile(); }

Allerdings gibt es davon abweichende Kurzschreibweisen. Um verschiedene Schreibweisen für Lambda-Ausdrücke zu demonstrieren, erfüllen die folgenden Code-Schnipsel alle dieselbe Funktionalität: In dem Verzeichnis "/MeinVerzeichnis" werden alle Dateien, aber keine Unterverzeichnisse aufgelistet, mit der Methode File.listFiles(FileFilter). Die Variable meinVerz ist definiert durch:

File meinVerz = new File( "/MeinVerzeichnis" );

File[] dateien = meinVerz.listFiles(
   new FileFilter() {
      @Override
      public boolean accept( File f ) {
         return f.isFile();
      }
   }
);

Weitere Bespiele für Lambda-Ausdrücke:

Default-Methoden, interne Iterierung, Mehrfachvererbung

Bis Java 7 konnten Interfaces nicht nachträglich erweitert werden, ohne die Rückwärtskompatibilität zu gefährden. Wenn ein Interface eine neue Methode erhält, müssen alle dieses Interface implementierende Klassen diese neue Methode implementieren, und können sonst nicht compiliert werden.

Ab Java 8 können Interfaces durch so genannte "Default-Methoden" erweitert werden, ohne die Rückwärtskompatibilität zu gefährden. Diese im Interface definierten Default-Methoden beinhalten eine Default-Implementierung, die bei Bedarf in der implementierenden Klasse überschrieben werden kann.

Beispiel für ein Interface mit Default-Methode:
Das Interface Iterable wurde in Java 8 um die Default-Methode forEach() erweitert, damit leichter über Collection-Elemente iteriert werden kann. Eine solche Iteration wird als "interne Iterierung" bezeichnet. Im Gegensatz zur herkömmlichen "externen Iterierung" bestimmt die Klasse selbst, wie und in welcher Reihenfolge die einzelnen Elemente durchlaufen und bearbeitet werden. Insbesondere könnten sie sogar parallel in getrennten Threads statt seriell bearbeitet werden.

Beispiel für eine interne Iterierung mit der neuen Default-Methode forEach():

List<String> meineListe = Arrays.asList( "Abc", "Xyz" );
meineListe.forEach( System.out::println );

Beispiel für interne Iterierungen mit den neuen Default-Methoden removeIf() und replaceAll():

List<String> meineStringListe = new ArrayList<>();
meineStringListe.add( "abc");
meineStringListe.add( "");
meineStringListe.add( "  def  ");
meineStringListe.add( null);
meineStringListe.add( "ghi");
meineStringListe.add( "  ");
meineStringListe.add( "xyz");
meineStringListe.removeIf( s -> s == null );
meineStringListe.replaceAll( String::trim );
meineStringListe.removeIf( String::isEmpty );
meineStringListe.forEach( System.out::println );

Während es in Java bis Java 7 keine Mehrfachvererbung gab, ist dies seit Java 8 in sehr eingeschränktem Umfang durch die neuen Default-Methoden möglich. Falls eine Klasse zwei Interfaces implementiert, welche beide eine Default-Methode mit identischer Signatur beinhalten, muss diese Klasse die Default-Methode überschreiben, indem sie eine eigene Implementierung definiert oder mit "super" angibt, welche Implementierung gelten soll:

interface MeinInterface1 {
  default void meineDefaultMethode() { System.out.println( "1" ); }
}
interface MeinInterface2 {
  default void meineDefaultMethode() { System.out.println( "2" ); }
}
class MeineKlasse implements MeinInterface1, MeinInterface2 {
  @Override public void meineDefaultMethode() {
    MeinInterface2.super.meineDefaultMethode();
  }
}

Streams und Bulk Operations on Collections

Die seit Java 8 in neuen Interfaces und Klassen vorwiegend in dem Package java.util.stream definierten "Streams" bieten eine Abstraktion für Folgen von Verarbeitungsschritten ("Stream Pipeline") auf Datensequenzen, beispielsweise in Collections.

Es gibt drei übergeordnete Kategorien von Stream-Operationen:

• Create Operations: erzeugen Streams. Beispiel: Collection.stream().
• Intermediate Operations: erzeugen aus einem Stream einen neuen Stream, sind "lazy", die Ausführung erfolgt erst durch eine "Terminal Operation".
  Typische Vertreter sind Filterfunktionen, bei denen die Menge der Elemente reduziert wird, sowie Mapping-Funktionen, bei den eine Berechnung, Extraktion oder Umwandlung durchgeführt wird. Beispiele: Stream.filter( Predicate ) und Stream.map( Function ).
• Terminal Operations: bilden den letzten Schritt, indem sie die Intermediate Operations ausführen ("eager"), häufig eine "Reduktion" auf ein Endergebnis erstellen, und die Stream Pipeline beenden. Beispiele: Stream.forEach( Consumer ), Stream.collect( Collector ) und Stream.reduce( BinaryOperator ).

Beispiele für "Create Operations":

String[]     meinArray  = { "Anton", "Berta", "Cäsar" };
List<String> meineListe = Arrays.asList( "Anton", "Berta", "Cäsar" );

Stream<Path> verzeichnisInhalt = Files.list( Paths.get( "C:/Temp/" ) );

Stream<String> zeilen = Files.lines( Paths.get( "MeineTextDatei.txt" ),
                                     StandardCharsets.UTF_8 );

Beispiele für "Intermediate Operations":

Stream<Integer> integerStream = Stream.of( 1, 2, 7, 42, 4711 );
Stream<File>    meineDateien  = Arrays.stream( (new File( "/MeinVerzeichnis" ))
                                               .listFiles() );

Stream<File> filtered = meineDateien.filter( File::isFile )
                                    .filter( f -> f.length() > 100 )
                                    .filter( f -> f.getName().startsWith( "X" ) );

Stream<File> filtered = meineDateien.filter( ((Predicate<File>) File::isFile)
                                     .and( f -> f.length() > 100 )
                                     .and( f -> f.getName().startsWith( "X" ) ) );

Stream<Path> alleTxtDateien = Files.list( Paths.get( "C:/Temp/" ) )
                .filter( path -> path.toString().endsWith( ".txt" ) );

Beispiele für "Terminal Operations" (bitte die Ergebnisse jeweils anzeigen mit System.out.println( ... )):

List<File> dateienListe = meineDateien.collect( Collectors.toCollection(
                                                         ArrayList::new ) );

Map<String,Long> dl = meineDateien.collect(
                         Collectors.toMap( File::getName, File::length ) );

Map<Boolean,List<File>> m = meineDateien.collect(
                               Collectors.groupingBy( File::canExecute ) );

Filter-Map-Reduce

"Filter-Map-Reduce" hat einige Analogien zu dem MapReduce-Algorithmus von Google, ist aber nicht dasselbe. Siehe hierzu auch Wikipedia.

"Filter-Map-Reduce" beschreibt ein Pattern, bei dem eine Menge von Daten in einer Abfolge von bestimmten Schritten verarbeitet werden:

• Filter: Filterung gewünschter Elemente aus einer Menge von Elementen. Die Element-Typen bleiben dieselben, aber die Menge der Elemente wird reduziert. Beispiel: Stream.filter( Predicate ).
• Map: Transformation der Elemente. Dabei ändert sich die Menge der Elemente nicht, aber oft ändert sich der Element-Typ. Beispielsweise können Berechnungen, Extraktionen oder Umwandlungen durchgeführt werden. Beispiel: Stream.map( Function ).
• Reduce: Reduktion auf ein Endergebnis. Beispiele: Stream.forEach( Consumer ), Stream.collect( Collector ) und Stream.reduce( BinaryOperator ).

Beispiele für "Filter-Map-Reduce" (lassen Sie sich jeweils das Ergebnis anzeigen mit System.out.println( ... )):

class Buch {
   String titel; String autor; int jahr; double preis;
   public Buch( String titel, String autor, int jahr, double preis ) {
      this.titel = titel; this.autor = autor;
      this.jahr = jahr; this.preis = preis;
   }
}
List<Buch> meineBuecherListe = Arrays.asList(
      new Buch( "Fortran", "Ferdinand", 1957, 57.99 ),
      new Buch( "Java in 3 Tagen", "Anton", 2005, 11.99 ),
      new Buch( "Java in 4 Tagen", "Berta", 2005, 22.99 ),
      new Buch( "Filter-Map-Reduce mit Lambdas", "Cäsar", 2014, 33.99 ) );

String s = meineBuecherListe.stream()
      .filter( b -> b.jahr >= 2004 )
      .map( b -> b.autor )
      .reduce( "", ( s1, s2 ) -> (s1.isEmpty()) ? s2 : s1 + ", " + s2 );

String s = meineBuecherListe.stream()
      .filter( b -> b.jahr >= 2004 )
      .map( b -> b.autor )
      .collect( Collectors.joining( ", " ) );

Map<Integer,Long> m = meineBuecherListe.stream()
      .filter( b -> b.jahr >= 2004 )
      .collect( Collectors.groupingBy( b -> Integer.valueOf( b.jahr ),
                                       Collectors.counting() ) );

OptionalDouble d = meineBuecherListe.stream()
      .filter( b -> b.jahr >= 2000 )
      .mapToDouble( b -> b.preis )
      .average();

OptionalDouble d = meineBuecherListe.stream()
      .peek( b -> System.out.println( b.titel + ", " + b.preis ) )
      .filter( b -> b.jahr >= 2000 )
      .mapToDouble( b -> b.preis )
      .peek( System.out::println )
      .average();

long anzahlZeichen = Files.lines( Paths.get( "MeineTextDatei.txt" ),
                                  StandardCharsets.UTF_8 )
      .mapToInt( String::length )
      .sum();

long anzahlWoerter = Files.lines( Paths.get( "MeineTextDatei.txt" ),
                                  StandardCharsets.UTF_8 )
      .flatMap( Pattern.compile( "[^\\p{L}]" )::splitAsStream )
      .count();

Filter-Map-Reduce mit paralleler Verarbeitung

Beispiel für "Filter-Map-Reduce" mit serieller und paralleler Verarbeitung (Definition von meineBuecherListe siehe oben):

OptionalDouble durchschnittlicherPreisAb2000seriell()
{
   Instant anfang = Instant.now();
   OptionalDouble avg = meineBuecherListe.stream()
         .filter( b -> b.jahr >= 2000 )
         .mapToDouble( b -> { try { Thread.sleep( 1000 );
                                  } catch( Exception e ) {}
                              return b.preis; } )
         .average();
   System.out.println( Duration.between( anfang, Instant.now() ) );
   return avg;
}

OptionalDouble durchschnittlicherPreisAb2000parallel()
{
   Instant anfang = Instant.now();
   OptionalDouble avg = meineBuecherListe.parallelStream()
         .filter( b -> b.jahr >= 2000 )
         .mapToDouble( b -> { try { Thread.sleep( 1000 );
                                  } catch( Exception e ) {}
                              return b.preis; } )
         .average();
   System.out.println( Duration.between( anfang, Instant.now() ) );
   return avg;
}

Nicht alle Intermediate Operations eignen sich gut zur Parallelisierung. Beachten Sie hierzu die Javadoc-Kommentare zu den Intermediate Operations, die häufig explizit darauf hinweisen, ob die Methode "stateful" oder "non-interfering, stateless" arbeitet. Sehen Sie sich hierzu auch die Stream-Package-Doku an.

Damit es bei der Parallelisierung nicht zu unerwünschten Nebenwirkungen kommt, beachten Sie unbedingt die Hinweise zu Concurrency (Multithreading).