Java 8-Tutorial
„Java lebt noch und die Leute fangen an, es zu verstehen.“
Willkommen zu meiner Einführung in Java 8. Dieser Artikel führt Sie Schritt für Schritt durch alle neuen Funktionen von Java 7 bis Java 8. Anhand schneller und einfacher Codebeispiele können wir lernen, wie man Standardschnittstellen
, Methodenreferenzen
usw. verwendet
Wiederholbare Anmerkungen . Am Ende des Artikels werden wir uns mit der Stream-API vertraut machen.
Kein unnötiges Geschwätz – nur Code und Kommentare! Nach vorne!
Standardmethoden für Schnittstellen
Java 8 ermöglicht es uns, nicht-abstrakte Methoden (die implementiert sind) zu Schnittstellen hinzuzufügen, indem wir das hinzufügen
default. Diese Funktion wird auch als
Erweiterungsmethoden bezeichnet . Unten ist das erste Beispiel:
interface Formula {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
Zusätzlich zur abstrakten Methode definiert
calculatedie Schnittstelle
Formulaauch eine Standardmethode
sqrt. Klassen, die diese Schnittstelle implementieren, müssen nur die implementieren
calculate. Die Standardmethode
sqrtkann sofort verwendet werden.
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
formula.calculate(100);
formula.sqrt(16);
Die Schnittstelle
Formulaist als anonyme Klasse implementiert. Der Code ist redundant: 6 Zeilen für die Implementierung
sqrt(a * 100). Wie wir im nächsten Abschnitt sehen werden, gibt es eine schönere Möglichkeit, eine einzelne Methode in Java 8 zu implementieren.
Lambda-Ausdrücke
Beginnen wir mit einem einfachen Beispiel für das Sortieren einer Liste von Zeichenfolgen in früheren Java-Versionen:
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});
Die statische Methode
Collections.sortakzeptiert eine Liste und einen Komparator in der Reihenfolge, in der die Liste sortiert werden soll. Sie können jederzeit eine anonyme Komparatorklasse erstellen und weitergeben. Anstatt eine anonyme Klasse zu erstellen, können Sie in Java 8 eine kürzere Notation, einen Lambda-Ausdruck, erstellen.
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
});
Wie Sie sehen, ist der Code viel kürzer und einfacher zu lesen. Aber das lässt sich noch kürzer machen:
Collections.sort(names, (String a, String b) -> b.compareTo(a));
Bei einem Textkörper mit einer Zeile können Sie
{}das Wort überspringen
return. Aber Sie können es noch kürzer machen:
Collections.sort(names, (a, b) -> b.compareTo(a));
Der Java-Compiler kennt Argumenttypen, daher können Sie diese auch überspringen. Lassen Sie uns tiefer in Lambda-Ausdrücke eintauchen und verstehen, wie sie verwendet werden können.
Funktionale Schnittstellen
Wie passen Lambda-Ausdrücke in das Java-Typsystem? Jedes Lambda entspricht einem in der Schnittstelle beschriebenen Typ. Daher sollte eine funktionale Schnittstelle nur eine abstrakte Methode enthalten. Jeder Lambda-Ausdruck dieses Typs entspricht dieser abstrakten Methode. Da Standardmethoden nicht abstrakt sind, können Sie nach Bedarf Standardmethoden in Funktionsschnittstellen erstellen. Wir können auch beliebige Schnittstellen als Lambda-Ausdrücke verwenden, wenn es in dieser Schnittstelle nur eine abstrakte Methode gibt. Um diese Anforderungen zu erfüllen, müssen Sie
@FucntionalInterfaceeine Anmerkung hinzufügen. Der Compiler weiß davon und löst eine Ausnahme aus, wenn Sie mehr als eine abstrakte Methode bereitstellen möchten. Beispiel:
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);
Beachten Sie, dass der Code auch kompiliert wird, wenn
@FunctionalInterfacedie Anmerkung weggelassen wird.
Methoden- und Konstruktorreferenzen
Das obige Beispiel kann auch durch die Verwendung von Methodenreferenzen noch kleiner gemacht werden:
Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);
Mit Java 8 können Sie Referenzen an eine Methode oder einen Konstruktor übergeben, indem Sie hinzufügen
::. Das obige Beispiel zeigt, wie wir auf eine statische Methode verweisen können, obwohl wir auch auf nicht statische Methoden verweisen können:
class Something {
String startsWith(String s) {
return String.valueOf(s.charAt(0));
}
}
Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);
Mal sehen, wie
::es mit Konstruktoren funktioniert. Zunächst definieren wir eine Beispielklasse mit verschiedenen Konstruktoren:
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
Als nächstes definieren wir eine Schnittstelle zum Erstellen neuer Objekte:
interface PersonFactory<P extends Person> {
P create(String firstName, String lastName);
}
Anstatt eine Erstellungsfabrik zu implementieren, verknüpfen wir alles mit
::Konstruktorhilfe:
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
Wir haben über . einen Link zum Konstruktor erstellt
Person::new. Der Java-Compiler wählt automatisch den richtigen Konstruktor aus, der der Methodensignatur entspricht
PersonFactory.create. ... Fortsetzung folgt. Leider habe ich keine Möglichkeit gefunden, einen Entwurf des Artikels zu speichern, und das ist wirklich seltsam, und die Zeit für die Übersetzung ist abgelaufen – also werde ich ihn später fertigstellen. Für alle, die Englisch können und verstehen –
Originalartikel . Wenn Sie Vorschläge zur Korrektur der Übersetzung haben, schreiben Sie auf eine Ihnen zur Verfügung stehende Weise.
Mein Github-Konto 
GO TO FULL VERSION