Die neueste Version der Java-Plattform, Java 8 wurde vor mehr als einem Jahr veröffentlicht. Viele Unternehmen und Entwickler arbeiten immer noch mit früheren Versionen, was verständlich ist, da es viele Probleme bei der Migration von einer Plattformversion auf eine andere gibt. Trotzdem fangen viele Entwickler noch an Neu Anwendungen mit alten Versionen von Java. Es gibt nur sehr wenige gute Gründe dafür, da Java 8 einige wichtige Verbesserungen in der Sprache gebracht hat.

Da sind viele Neue Eigenschaften in Java 8. Ich zeige Ihnen eine Handvoll der nützlichsten und interessantesten:

• Lambda-Ausdrücke
• Stream-API für die Arbeit mit Sammlungen
• Asynchrone Taskverkettung mit CompletableFuture
• Brandneue Zeit-API

Lambda-Ausdrücke

ZU Lambda ist ein Codeblock, auf den verwiesen und zur zukünftigen Ausführung ein- oder mehrmals an einen anderen Code übergeben werden kann. Anonyme Funktionen in anderen Sprachen sind beispielsweise Lambdas. Wie Funktionen können Lambdas zum Zeitpunkt ihrer Ausführung Argumente übergeben werden, wodurch ihre Ergebnisse geändert werden. Java 8 eingeführt Lambda-Ausdrücke , die eine einfache Syntax zum Erstellen und Verwenden von Lambdas bieten.

Sehen wir uns ein Beispiel an, wie dies unseren Code verbessern kann. Hier haben wir einen einfachen Komparator, der zwei Integer vergleicht Werte durch ihr Modulo 2:

class BinaryComparator implements Comparator{ @Override public int compare(Integer i1, Integer i2) { return i1 % 2 - i2 % 2; } }

Eine Instanz dieser Klasse kann in Zukunft in Code aufgerufen werden, in dem dieser Komparator benötigt wird, wie folgt:

... List list = ...; Comparator comparator = new BinaryComparator(); Collections.sort(list, comparator); ...

Die neue Lambda-Syntax ermöglicht es uns, dies einfacher zu machen. Hier ist ein einfacher Lambda-Ausdruck, der dasselbe tut wie compare Methode von BinaryComparator:

(Integer i1, Integer i2) -> i1 % 2 - i2 % 2;

Die Struktur hat viele Ähnlichkeiten mit einer Funktion. In Klammern erstellen wir eine Liste von Argumenten. Die Syntax -> zeigt, dass dies ein Lambda ist. Und im rechten Teil dieses Ausdrucks stellen wir das Verhalten unseres Lambda ein.

Jetzt können wir unser vorheriges Beispiel verbessern:

... List list = ...; Collections.sort(list, (Integer i1, Integer i2) -> i1 % 2 - i2 % 2); ...

Wir können mit diesem Objekt eine Variable definieren. Mal sehen, wie es aussieht:

Comparator comparator = (Integer i1, Integer i2) -> i1 % 2 - i2 % 2;

Jetzt können wir diese Funktionalität wie folgt wiederverwenden:

... List list1 = ...; List list2 = ...; Collections.sort(list1, comparator); Collections.sort(list2, comparator); ...

Beachten Sie, dass in diesen Beispielen das Lambda an sort() übergeben wird Methode auf die gleiche Weise wie die Instanz von BinaryComparator wird im vorherigen Beispiel übergeben. Woher weiß die JVM, wie man das Lambda richtig interpretiert?

Damit Funktionen Lambdas als Argumente verwenden können, führt Java 8 ein neues Konzept ein: funktionale Schnittstelle . Eine funktionale Schnittstelle ist eine Schnittstelle, die nur eine abstrakte Methode hat. In Java 8 werden Lambda-Ausdrücke als spezielle Implementierung einer funktionalen Schnittstelle behandelt. Dies bedeutet, dass der deklarierte Typ dieses Arguments nur eine funktionale Schnittstelle sein muss, um ein Lambda als Methodenargument zu erhalten.

Wenn wir eine funktionale Schnittstelle deklarieren, können wir @FunctionalInterface hinzufügen Notation, um Entwicklern zu zeigen, was es ist:

@FunctionalInterface private interface DTOSender { void send(String accountId, DTO dto); } void sendDTO(BisnessModel object, DTOSender dtoSender) { //some logic for sending... ... dtoSender.send(id, dto); ... }

Jetzt können wir die Methode sendDTO aufrufen und verschiedene Lambdas übergeben, um ein unterschiedliches Verhalten zu erreichen, wie folgt:

sendDTO(object, ((accountId, dto) -> sendToAndroid(accountId, dto))); sendDTO(object, ((accountId, dto) -> sendToIos(accountId, dto)));

Methodenreferenzen

Mit Lambda-Argumenten können wir das Verhalten einer Funktion oder Methode ändern. Wie wir im letzten Beispiel sehen können, dient das Lambda manchmal nur dazu, eine andere Methode aufzurufen (sendToAndroid oder sendToIos). Für diesen speziellen Fall führt Java 8 eine praktische Kurzform ein: Methodenreferenzen . Diese abgekürzte Syntax stellt ein Lambda dar, das eine Methode aufruft und die Form objectName::methodName hat. Auf diese Weise können wir das vorherige Beispiel noch präziser und lesbarer machen:

sendDTO(object, this::sendToAndroid); sendDTO(object, this::sendToIos);

In diesem Fall die Methoden sendToAndroid und sendToIos sind in this implementiert Klasse. Wir können auch auf die Methoden eines anderen Objekts oder einer anderen Klasse verweisen.

Stream-API

Java 8 bietet neue Funktionen für die Arbeit mit Collections in Form einer brandneuen Stream-API. Diese neue Funktionalität wird von java.util.stream bereitgestellt Paket, und zielt darauf ab, eine mehr zu ermöglichen funktional Ansatz zur Programmierung mit Sammlungen. Wie wir sehen werden, ist dies hauptsächlich dank der neuen Lambda-Syntax möglich, die wir gerade besprochen haben.

Die Stream-API bietet eine einfache Filterung, Zählung und Zuordnung von Sammlungen sowie verschiedene Möglichkeiten, um Slices und Teilmengen von Informationen daraus abzurufen. Dank der Syntax im funktionalen Stil ermöglicht die Stream-API kürzeren und eleganteren Code für die Arbeit mit Sammlungen.

Beginnen wir mit einem kurzen Beispiel. Wir werden dieses Datenmodell in allen Beispielen verwenden:

class Author { String name; int countOfBooks; } class Book { String name; int year; Author author; }

Stellen wir uns vor, wir müssen alle Autoren in einem books drucken Sammlung, die nach 2005 ein Buch geschrieben hat. Wie würden wir es in Java 7 machen?

for (Book book : books) { if (book.author != null && book.year > 2005){ System.out.println(book.author.name); } }

Und wie würden wir das in Java 8 machen?

books.stream() .filter(book -> book.year > 2005) // filter out books published in or before 2005 .map(Book::getAuthor) // get the list of authors for the remaining books .filter(Objects::nonNull) // remove null authors from the list .map(Author::getName) // get the list of names for the remaining authors .forEach(System.out::println); // print the value of each remaining element

Es ist nur ein Ausdruck! Aufruf der Methode stream() auf jedem Collection gibt ein Stream zurück Objekt, das alle Elemente dieser Sammlung einschließt. Dies kann mit verschiedenen Modifikatoren aus der Stream-API wie filter() bearbeitet werden und map(). Jeder Modifikator gibt ein neues Stream zurück Objekt mit den Ergebnissen der Modifikation, die weiter manipuliert werden können. Die .forEach() Mit dieser Methode können wir für jede Instanz des resultierenden Streams eine Aktion ausführen.

Dieses Beispiel zeigt auch die enge Beziehung zwischen funktionaler Programmierung und Lambda-Ausdrücken. Beachten Sie, dass das an jede Methode im Stream übergebene Argument entweder ein benutzerdefiniertes Lambda oder eine Methodenreferenz ist. Technisch gesehen kann jeder Modifikator jede funktionale Schnittstelle empfangen, wie im vorherigen Abschnitt beschrieben.

Die Stream-API hilft Entwicklern, Java-Sammlungen aus einem neuen Blickwinkel zu betrachten. Stellen Sie sich jetzt vor, wir brauchen ein Map der verfügbaren Sprachen in jedem Land. Wie würde dies in Java 7 implementiert werden?

Map countryToSetOfLanguages = new HashMap(); for (Locale locale : Locale.getAvailableLocales()){ String country = locale.getDisplayCountry(); if (!countryToSetOfLanguages.containsKey(country)){ countryToSetOfLanguages.put(country, new HashSet()); } countryToSetOfLanguages.get(country).add(locale.getDisplayLanguage()); }

In Java 8 sind die Dinge etwas ordentlicher:

import java.util.stream.*; import static java.util.stream.Collectors.*; ... Map countryToSetOfLanguages = Stream.of(Locale.getAvailableLocales()) .collect(groupingBy(Locale::getDisplayCountry, mapping(Locale::getDisplayLanguage, toSet())));

Die Methode collect() ermöglicht es uns, die Ergebnisse eines Streams auf verschiedene Arten zu sammeln. Hier können wir sehen, dass es zuerst nach Land gruppiert und dann jede Gruppe nach Sprache abbildet. (groupingBy() und toSet() sind beide statische Methoden aus der Klasse Collectors.)

Es gibt viele andere Fähigkeiten der Stream-API. Die vollständige Dokumentation finden Sie hier Hier . Ich empfehle, weiterzulesen, um ein tieferes Verständnis für alle leistungsstarken Tools zu erhalten, die dieses Paket bietet.

Asynchrone Aufgabenverkettung mit CompletableFuture

In Java 7 java.util.concurrent Paket gibt es eine Schnittstelle Future Dies ermöglicht es uns, den Status oder das Ergebnis einer asynchronen Aufgabe in der Zukunft abzurufen. Um diese Funktionalität nutzen zu können, müssen wir:

1. Erstelle ein ExecutorService , die die Ausführung von asynchronen Tasks verwaltet und Future generieren kann Objekte, um ihren Fortschritt zu verfolgen.
2. Erstellen Sie eine asynchrone Runnable Aufgabe.
3. Führen Sie die Aufgabe in ExecutorService aus, wodurch ein Future bereitgestellt wird Zugriff auf den Status oder die Ergebnisse gewähren.

Um die Ergebnisse einer asynchronen Aufgabe nutzen zu können, muss ihr Fortschritt von außen mit den Methoden von Future überwacht werden Wenn die Schnittstelle fertig ist, rufen Sie die Ergebnisse explizit ab und führen Sie weitere Aktionen mit ihnen aus. Die fehlerfreie Implementierung kann sehr komplex sein, insbesondere in Anwendungen mit einer großen Anzahl gleichzeitiger Aufgaben.

In Java 8 ist jedoch das Future Konzept wird weitergeführt, mit dem CompletableFuture Schnittstelle, die die Erstellung und Ausführung von Ketten asynchroner Aufgaben ermöglicht. Es ist ein leistungsstarker Mechanismus zum Erstellen asynchroner Anwendungen in Java 8, da wir die Ergebnisse jeder Aufgabe nach Abschluss automatisch verarbeiten können.

Sehen wir uns ein Beispiel an:

import java.util.concurrent.CompletableFuture; ... CompletableFuture voidCompletableFuture = CompletableFuture.supplyAsync(() -> blockingReadPage()) .thenApply(this::getLinks) .thenAccept(System.out::println);

Die Methode CompletableFuture.supplyAsync Erstellt eine neue asynchrone Aufgabe in der Standardeinstellung Executor (normalerweise ForkJoinPool ). Wenn die Aufgabe beendet ist, werden ihre Ergebnisse automatisch als Argumente an die Funktion this::getLinks übergeben, die auch in einer neuen asynchronen Aufgabe ausgeführt wird. Schließlich werden die Ergebnisse dieser zweiten Stufe automatisch auf System.out gedruckt. thenApply() und thenAccept() sind nur zwei von mehreren nützliche Methoden verfügbar, um Sie beim gleichzeitigen Erstellen von Aufgaben zu unterstützen, ohne Executors manuell zu verwenden.

Die CompletableFuture erleichtert die Verwaltung der Sequenzierung komplexer asynchroner Vorgänge. Angenommen, wir müssen eine mehrstufige mathematische Operation mit drei Aufgaben erstellen. Aufgabe 1 und Aufgabe 2 Verwenden Sie verschiedene Algorithmen, um ein Ergebnis für den ersten Schritt zu finden, und wir wissen, dass nur einer von ihnen funktioniert, während der andere fehlschlägt. Welche man arbeitet, hängt jedoch von den Eingabedaten ab, die wir nicht im Voraus kennen. Das Ergebnis dieser Aufgaben muss mit dem Ergebnis von summiert werden Aufgabe 3 . Daher müssen wir das Ergebnis von beiden finden Aufgabe 1 oder Aufgabe 2 , und das Ergebnis von Aufgabe 3 . Um dies zu erreichen, können wir so etwas schreiben:

import static java.util.concurrent.CompletableFuture.*; ... Supplier task1 = (...) -> { ... // some complex calculation return 1; // example result }; Supplier task2 = (...) -> { ... // some complex calculation throw new RuntimeException(); // example exception }; Supplier task3 = (...) -> { ... // some complex calculation return 3; // example result }; supplyAsync(task1) // run task1 .applyToEither( // use whichever result is ready first, result of task1 or supplyAsync(task2), // result of task2 (Integer i) -> i) // return result as-is .thenCombine( // combine result supplyAsync(task3), // with result of task3 Integer::sum) // using summation .thenAccept(System.out::println); // print final result after execution

Wenn wir untersuchen, wie Java 8 damit umgeht, werden wir feststellen, dass alle drei Aufgaben gleichzeitig asynchron ausgeführt werden. Trotz Aufgabe 2 Wenn dies mit einer Ausnahme fehlschlägt, wird das Endergebnis erfolgreich berechnet und gedruckt.

CompletableFuture erleichtert das Erstellen asynchroner Aufgaben mit mehreren Phasen erheblich und bietet eine einfache Schnittstelle, über die genau definiert werden kann, welche Aktionen nach Abschluss jeder Phase ausgeführt werden sollen.

Java-API für Datum und Uhrzeit

Wie von Java angegeben eigene Aufnahme ::

Vor der Veröffentlichung von Java SE 8 wurde der Java-Mechanismus für Datum und Uhrzeit von der bereitgestellt java.util.Date , java.util.Calendar , und java.util.TimeZone Klassen sowie deren Unterklassen wie java.util.GregorianCalendar. Diese Klassen hatten mehrere Nachteile, einschließlich

• Die Calendar-Klasse war nicht typsicher.
• Da die Klassen veränderbar waren, konnten sie nicht in Multithread-Anwendungen verwendet werden.
• Fehler im Anwendungscode waren aufgrund der ungewöhnlichen Anzahl von Monaten und der mangelnden Typensicherheit häufig. “

Java 8 löst endlich diese langjährigen Probleme mit dem neuen java.time Paket, das Klassen zum Arbeiten mit Datum und Uhrzeit enthält. Alle von ihnen sind unveränderlich und haben APIs ähnlich dem populären Framework Joda-Zeit , die fast alle Java-Entwickler in ihren Anwendungen anstelle der nativen Date, Calendar und TimeZone verwenden.

Hier sind einige der nützlichen Klassen in diesem Paket:

• Clock - Eine Uhr, die die aktuelle Uhrzeit anzeigt, einschließlich des aktuellen Zeitpunkts, des Datums und der Uhrzeit mit Zeitzone.
• Duration , und Period - Eine Menge Zeit. Duration verwendet zeitbasierte Werte wie '76,8 Sekunden' und Period datumsbasiert wie '4 Jahre, 6 Monate und 12 Tage'.
• Instant - Ein augenblicklicher Zeitpunkt in verschiedenen Formaten.
• LocalDate , LocalDateTime , LocalTime , Year , YearMonth - Ein Datum, eine Uhrzeit, ein Jahr, ein Monat oder eine Kombination davon ohne Zeitzone im ISO-8601-Kalendersystem.
• OffsetDateTime , OffsetTime - Eine Datums- und Uhrzeitangabe mit einem Versatz von UTC / Greenwich im ISO-8601-Kalendersystem, z. B. „2015-08-29T14: 15: 30 + 01: 00“.
• ZonedDateTime - Eine Datums- und Uhrzeitangabe mit einer zugeordneten Zeitzone im ISO-8601-Kalendersystem, z. B. „1986-08-29T10: 15: 30 + 01: 00 Europe / Paris“.

Manchmal müssen wir ein relatives Datum finden, z. B. den „ersten Dienstag des Monats“. Für diese Fälle java.time bietet eine spezielle Klasse TemporalAdjuster . Die TemporalAdjuster Die Klasse enthält einen Standardsatz von Einstellern, die als statische Methoden verfügbar sind. Diese ermöglichen es uns:

• Finden Sie den ersten oder letzten Tag des Monats.
• Finden Sie den ersten oder letzten Tag des nächsten oder vorherigen Monats.
• Finden Sie den ersten oder letzten Tag des Jahres.
• Finden Sie den ersten oder letzten Tag des nächsten oder vorherigen Jahres.
• Suchen Sie den ersten oder letzten Wochentag innerhalb eines Monats, z. B. 'erster Mittwoch im Juni'.
• Suchen Sie den nächsten oder vorherigen Wochentag, z. B. 'Nächster Donnerstag'.

Hier ist ein kurzes Beispiel, wie Sie den ersten Dienstag des Monats erhalten:

LocalDate getFirstTuesday(int year, int month) { return LocalDate.of(year, month, 1) .with(TemporalAdjusters.nextOrSame(DayOfWeek.TUESDAY)); } Verwenden Sie immer noch Java 7? Holen Sie sich mit dem Programm! # Java8 Tweet

Java 8 in der Zusammenfassung

Wie wir sehen können, ist Java 8 eine epochale Version der Java-Plattform. Es gibt viele Sprachänderungen, insbesondere mit der Einführung von Lambdas, was einen Schritt darstellt, um mehr funktionale Programmierfähigkeiten in Java zu bringen. Die Stream-API ist ein gutes Beispiel dafür, wie Lambdas die Art und Weise ändern können, wie wir mit Standard-Java-Tools arbeiten, an die wir bereits gewöhnt sind.

Außerdem bietet Java 8 einige neue Funktionen zum Arbeiten asynchrone Programmierung und eine dringend benötigte Überarbeitung seiner Datums- und Uhrzeit-Tools.

Zusammen stellen diese Änderungen einen großen Fortschritt für die Java-Sprache dar Java-Entwicklung interessanter und effizienter.