Java 8 - Die Neuerungen

Lambdas, Streams, Date and Time API und JavaFX 8 im Überblick

Michael Inden

• Verlag: dpunkt
• Jahr: 2015
• ISBN:
  9783864917509
• Auflage: 2
• Thema: Ciencia de la computación
• Thema: Programación en Java

Dieses Buch bietet einen fundierten Einstieg in Java 8 sowie einen Überblick über die umfangreichen Neuerungen in JDK 8. Damit eignet sich das Buch für all jene, die ihr Java-Wissen auffrischen und aktualisieren wollen.Die aktuelle Java-Version enthält zahlreiche Erweiterungen. Insbesondere die Einführung von Lambdas und des Stream-APIs stellen wegweisende Entwicklungen dar, die nun neben der objektorientierten auch die funktionale Programmierung in Java ermöglichen. Jeder ambitionierte Java-Entwickler sollte sie kennen, weil sich dadurch vollkommen neue Gestaltungsmöglichkeiten ergeben.Die Verarbeitung von Datumswerten hat eine grundlegene Überarbeitung erfahren und erleichtert die Daumsarithmetik enorm. Doch damit nicht genug: Die GUI-Technologie JavaFX wurde um einige neue Bedienelemente sowie Dialoge und die Unterstützung für 3D erweitert und schickt sich an, Swing abzulösen.Darüber hinaus geht der Autor auf diverse weitere Neuerungen ein, die JDK 8 bietet.In dieser zweiten Auflage wurden Kapitel zu Java 8 im Praxiseinsatz sowie zur Migration bestehender Projekte auf das neue JDK 8 ergänzt. Abgerundet wird dieses Buch durch einen Ausblick auf mögliche Funktionalitäten in JDK 9.

1 Einleitung

Am 18. März 2014 war es endlich so weit: Das zuvor mehrfach verschobene und lang erwartete Java 8 ist erschienen. Dieses Release enthält diverse wegweisende Erweiterungen und mit Lambda-Ausdrücken ein neues Sprachkonstrukt, das die funktionale Programmierung in Java erlaubt. Durch ein sorgfältiges API-Design von Massenoperationen auf Collections (Bulk Operations on Collections), wie Filterung, Transformation und Sortierung, lässt sich die funktionale gut mit der objektorientierten Programmierung verbinden. Dadurch ergeben sich vollkommen neue Gestaltungsmöglichkeiten, die jeder ambitionierte Java-Entwickler beherrschen sollte. Auch die lange Zeit stiefmütterlich behandelte Verarbeitung von Datumswerten wurde in Java 8 vollständig überarbeitet. Doch damit nicht genug: JavaFX als GUI-Technologie wurde aufpoliert. Darüber hinaus gibt es eine Vielzahl weiterer Funktionalitäten in Java 8 zu entdecken. Dieses Buch gibt einen Überblick über folgende wesentliche Erweiterungen in JDK 8:

• Lambda-Ausdrücke, Defaultmethoden und Methodenreferenzen Zunächst werden wir mit Lambdas, Methodenreferenzen und Defaultmethoden die Grundlagen zur funktionalen Programmierung mit Java kennenlernen.
• Bulk Operations on Collections Viele Aufgabenstellungen wie Filterungen und Transformationen erfordern den Einsatz von Collections und spezieller Algorithmen. Bis JDK 8 fehlte es allerdings an geeigneter Unterstützung, was sich nun ändert. Die neu eingeführten Streams bieten weitreichende Möglichkeiten zur Datenverarbeitung und zur Parallelisierung von Verarbeitungsschritten.
• Date and Time API Die Verarbeitung von Datums- und Zeitangaben war bis Java 8 immer mühselig und fehlerträchtig. Das neue Date and Time API vereinfacht das Ganze erheblich.
• JavaFX 8 Viele GUIs, die auf Swing basieren, wirken altbacken. Abhilfe schafft hier JavaFX als neue Oberflächentechnologie. Wir betrachten Verbesserungen in JavaFX 8 und schauen kurz auf die Realisierung von Darstellungen in 3D.
• Diverse weitere Änderungen Im JDK findet sich eine Vielzahl größerer und kleinerer Verbesserungen und Neuerungen. Von den diversen weiteren Änderungen in JDK 8 behandle ich stellvertretend und überblicksartig verschiedenste Themen wie Parallel Array Sorting, Überarbeitung der Garbage Collection, die Unterstützung von Base64 u. v. m.

Die aufgelisteten Themen stelle ich in jeweils separaten Kapiteln vor. Den Abschluss dieses Buchs bildet eine Beschreibung über bereits für JDK 7 vorgesehene Sprachfeatures, die es leider auch nicht in JDK 8 geschafft haben.

Hinweis: Umfang von JDK 8

Schon der Releasetermin von JDK 7 wurde einige Male nach hinten verlegt. Das geschah unter anderem, weil die Fertigstellung verschiedener Features wie Lambda-Ausdrücke, Modularisierung, ein neues Date and Time API usw. viel länger dauerte als geplant. Schließlich wurden etliche Funktionalitäten aus Zeitmangel von JDK 7 auf JDK 8 verschoben.

Wer nun gedacht hätte, dass alle diese Funktionalitäten tatsächlich im JDK 8 enthalten sein würden, wird enttäuscht. Die Geschichte des Verschiebens und Abkündigens von Features wiederholt sich auch für JDK 8. Trotz mehrfacher Verzögerungen wurden einige Features leider nicht realisiert, wie z. B. die Modularisierung. Somit verbleibt als bedeutendste Neuerung in JDK 8 die Einführung von Lambda-Ausdrücken – allerdings sind deren Auswirkungen wirklich umfangreich und ziehen sich durch verschiedenste Teile des JDKs.

Entdeckungsreise JDK 8 – Wünsche an die Leser

Ich wünsche allen Lesern viel Freude mit diesem Buch zu Java 8 sowie einige neue Erkenntnisse und viel Spaß bei eigenen Experimenten mit JDK 8. Möge Ihnen der Umstieg auf Lambdas und die funktionale Programmierung mit meinem Buch ein wenig leichter fallen.

Lassen Sie uns nun die Entdeckungsreise durch JDK 8 und seine Neuerungen mit einem Einstieg in das Thema Lambda-Ausdrücke beginnen. Wenn Sie zunächst ein wenig mehr zu funktionaler Programmierung erfahren wollen, bietet sich ein Blick in den Anhang A an.

2 Lambda-Ausdrücke

Mit Lambda-Ausdrücken (kurz: Lambdas, zum Teil auch Closures genannt) wurde ein neues und von vielen Entwicklern heiß ersehntes Sprachkonstrukt in Java eingeführt, das bereits in ähnlicher Form in verschiedenen anderen Programmiersprachen wie C#, Groovy und Scala erfolgreich genutzt wird. Der Einsatz von Lambdas erfordert zum Teil eine andere Denkweise und führt zu einem neuen Programmierstil, der dem Paradigma der funktionalen Programmierung folgt. Mithilfe von Lambdas lassen sich einige Lösungen auf sehr elegante Art und Weise formulieren. Insbesondere im Bereich von Frameworks und zur Parallelverarbeitung kann die Verwendung von Lambdas enorme Vorteile bringen. Diverse Funktionalitäten im Collections-Framework und an anderen Stellen des JDKs wurden auf Lambdas umgestellt. Bevor wir darauf zurückkommen, schauen wir uns zunächst einmal Lambdas an sich an.

Beispiel: Sortierung nach Länge und kommaseparierte Aufbereitung

Um die Vorteile von Lambdas und auch später von den sogenannten Bulk Operations on Collections besser nachvollziehen zu können, betrachten wir als praxisnahes Beispiel eine Liste von Namen. Diese Namen wollen wir nach deren Länge sortieren und die Längen danach kommasepariert ausgeben. Dazu würden wir bis einschließlich JDK 7 in etwa folgenden Sourcecode schreiben:

// Sortierung mit Comparator
final List<String> names = Arrays.asList("Andy", "Michael", "Max", "Stefan");
Collections.sort(names, new Comparator<String>()
{
@Override
public int compare(final String str1, final String str2)
{
return Integer.compare(str1.length(), str2.length());
}
});

// Iteration und Ausgabe
final Iterator<String> it = names.iterator();
while (it.hasNext())
{
System.out.print(it.next().length() + ", "); // 3, 4, 6, 7,
}

Beim Betrachten dieser Umsetzung kann man sich fragen, ob das nicht kürzer und einfacher gehen sollte? Die Antwort ist: Ja, mit JDK 8 kann man dazu Lambdas nutzen.

2.1 Einstieg in Lambdas

Das Sprachkonstrukt Lambda kommt aus der funktionalen Programmierung. Ein Lambda ist ein Behälter für Sourcecode ähnlich einer Methode, allerdings ohne Namen und ohne die explizite Angabe eines Rückgabetyps oder ausgelöster Exceptions. Vereinfacht ausgedrückt kann man einen Lambda am ehesten als anonyme Methode mit folgender Syntax und spezieller Kurzschreibweise auffassen:

(Parameter-Liste) -> { Ausdruck oder Anweisungen }

2.1.1 Lambdas am Beispiel

Ein paar recht einfache Beispiele für Lambdas sind die Addition von zwei Zahlen vom Typ int, die Multiplikation eines long-Werts mit dem Faktor 2 oder eine parameterlose Funktion zur Ausgabe eines Textes auf der Konsole. Diese Aktionen kann man als Lambdas wie folgt schreiben:

(int x, int y) -> { return x + y; }
(long x) -> { return x * 2; }
() -> { String msg = "Lambda"; System.out.println("Hello " + msg); }

Das sieht recht unspektakulär aus, und insbesondere wird klar, dass ein Lambda lediglich ein Stück ausführbarer Sourcecode ist, der

• keinen Namen besitzt, sondern lediglich Funktionalität, und dabei
• keine explizite Angabe eines Rückgabetyps und
• keine Deklaration von Exceptions erfordert und erlaubt.

Lambdas im Java-Typsystem

Wir haben bisher gesehen, dass sich einfache Berechnungen mithilfe von Lambdas ausdrücken lassen. Wie können wir diese aber nutzen und aufrufen? Versuchen wir zunächst, einen Lambda einer java.lang.Object-Referenz zuzuweisen, so wie wir es mit jedem anderen Objekt in Java auch tun können:

// Compile-Error: incompatible types: Object is not a functional in...