Verwenden Sie Lambda-Ausdrücke, um die Lesbarkeit und Wartbarkeit von Java-Code zu verbessern

Einführung

Java ist eine leistungsstarke Programmiersprache, die umfangreiche Funktionen und APIs bietet, um verschiedene Arten von Anwendungsanforderungen zu erfüllen. In der tatsächlichen Entwicklung stellen wir jedoch häufig fest, dass der Java-Code zu lang und zu kompliziert ist, um ihn zu verstehen und zu warten. Zu diesem Zeitpunkt müssen wir einige moderne Programmiertechniken und -methoden verwenden, um die Lesbarkeit und Wartbarkeit des Codes zu verbessern. Der Lambda-Ausdruck ist eine neue Funktion, die von Java 8 eingeführt wurde und uns dabei helfen kann, Code zu vereinfachen und die Entwicklungseffizienz zu verbessern. In diesem Artikel werden die Prinzipien, die Verwendung und Best Practices von Lambda-Ausdrücken vorgestellt, um Ihnen dabei zu helfen, Lambda-Ausdrücke besser anzuwenden und die Lesbarkeit und Wartbarkeit von Java-Code zu verbessern.

1. Das Grundprinzip des Lambda-Ausdrucks

Vor Java 8 verwenden wir normalerweise anonyme innere Klassen, um funktionale Programmierung zu implementieren. Eine anonyme innere Klasse ist eine leichtgewichtige Klassendefinition, die normalerweise zum Erstellen einer Klasseninstanz mit nur einer Methode verwendet wird. Der folgende Code erstellt beispielsweise eine anonyme innere Klasse, die die Comparator-Schnittstelle zum Sortieren von Zeichenfolgen nach Länge implementiert:

List<String> list = Arrays.asList("aaa", "bb", "c");
Collections.sort(list, new Comparator<String>() {
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
});

Die Logik dieses Codes besteht darin, die Längen der Zeichenfolgen zu vergleichen und sie in aufsteigender Reihenfolge der Länge zu sortieren. Unter anderem definiert die Comparator-Schnittstelle eine Vergleichsmethode zum Vergleichen der Größe zweier Objekte. Die anonyme innere Klasse implementiert diese Schnittstelle und überschreibt die Vergleichsmethode zur einfacheren Sortierung.

Allerdings hat diese Notation einige Nachteile. Erstens ist die Syntax anonymer innerer Klassen langwierig und kompliziert, was leicht zu einer schlechten Lesbarkeit des Codes führen kann. Zweitens ist eine anonyme innere Klasse normalerweise nur ein syntaktischer Zucker, sie kapselt den Code nicht wirklich in eine Funktion. Das bedeutet, dass wir keine Parametrisierungs-, Kompositions- usw. Operationen an anonymen inneren Klassen wie gewöhnlichen Funktionen durchführen können.

Die Entstehung von Lambda-Ausdrücken soll diese Probleme lösen. Ein Lambda-Ausdruck kann als anonyme Funktion betrachtet werden, die keine Klassendefinition erfordert und direkt durch eine Anweisung dargestellt wird. Beispielsweise können wir Lambda-Ausdrücke verwenden, um den obigen Code zu implementieren:

List<String> list = Arrays.asList("aaa", "bb", "c");
Collections.sort(list, (s1, s2) -> Integer.compare(s1.length(), s2.length()));

Die Logik dieses Codes ist dieselbe wie die des vorherigen Codes, außer dass ein Lambda-Ausdruck verwendet wird, um die Definition der Vergleichsfunktion zu vereinfachen. Darunter stellt eine Funktion (s1, s2) -> Integer.compare(s1.length(), s2.length())dar , die zwei Parameter s1 und s2 akzeptiert und das Vergleichsergebnis ihrer Längen zurückgibt.

Die Syntax eines Lambda-Ausdrucks besteht aus drei Teilen: der Parameterliste, der Pfeilnotation und dem Funktionskörper . Darunter definieren die Parameterliste und das Pfeilsymbol die Eingabe des Lambda-Ausdrucks, und der Funktionskörper definiert die Ausgabe des Lambda-Ausdrucks. Der Typ des Lambda-Ausdrucks wird durch seinen Kontext bestimmt. Im obigen Beispiel ist der Typ des Lambda-Ausdrucks Comparator<String>, da er an die Collections.sort-Methode übergeben wird.

Ein weiterer Vorteil von Lambda-Ausdrücken besteht darin, dass damit einige zusammengesetzte Vorgänge wie Kombinationen, Filterungen, Zuordnungen usw. ausgeführt werden können. Beispielsweise können wir mithilfe von Lambda-Ausdrücken eine Liste von Zeichenfolgen filtern und zuordnen:

List<String> list = Arrays.asList("aaa", "bb", "c");
List<String> filtered = list.stream()
        .filter(s -> s.length() > 1)
        .map(s -> s.toUpperCase())
        .collect(Collectors.toList());

Die Logik dieses Codes besteht darin, zuerst die Zeichenfolgen herauszufiltern, deren Länge kleiner oder gleich 1 ist, dann die verbleibenden Zeichenfolgen in Großbuchstaben umzuwandeln und sie in einer neuen Liste zu speichern. Unter diesen konvertiert die Stream-Methode eine Liste in einen Stream, die Filtermethode wird zum Filtern von Elementen verwendet, die Map-Methode wird zum Konvertieren von Elementen in neue Werte verwendet und die Collect-Methode wird zum Sammeln von Elementen im Stream in einer Liste verwendet.

Durch Lambda-Ausdrücke können wir komplexe Vorgänge einfach implementieren, ohne viel langen Code schreiben zu müssen. Im Folgenden stellen wir vor, wie Sie Lambda-Ausdrücke verwenden, um die Lesbarkeit und Wartbarkeit von Java-Code zu verbessern.

2. Verwenden Sie Lambda-Ausdrücke, um die Lesbarkeit und Wartbarkeit von Java-Code zu verbessern

1. Ersetzen Sie die anonyme innere Klasse durch einen Lambda-Ausdruck

Wie bereits erwähnt, können Lambda-Ausdrücke Code ersetzen, der anonyme innere Klassen verwendet. Die Verwendung von Lambda-Ausdrücken kann die Codemenge reduzieren und den Code prägnanter und verständlicher machen. Der folgende Code verwendet beispielsweise eine anonyme innere Klasse, um einen Thread zu erstellen:

new Thread(new Runnable() {
    public void run() {
        System.out.println("Hello, world!");
    }
}).start();

Wir können Lambda-Ausdrücke verwenden, um anonyme innere Klassen zu ersetzen:

new Thread(() -> System.out.println("Hello, world!")).start();

Die Logik dieses Codes lautet: Erstellen Sie einen neuen Thread, der während der Ausführung eine Nachricht ausgibt. Darunter () -> System.out.println("Hello, world!")stellt es einen Lambda-Ausdruck ohne Parameter dar, dessen Funktionskörper darin besteht, eine Information auszugeben.

2. Verwenden Sie Lambda-Ausdrücke, um Filtervorgänge zu vereinfachen

In Java müssen wir häufig Daten filtern. Normalerweise verwenden wir Schleifen, um die Daten zu durchlaufen, und verwenden if-Anweisungen, um zu überprüfen, ob bestimmte Bedingungen erfüllt sind. Dies kann mithilfe von Lambda-Ausdrücken vereinfacht werden:

List<String> list = Arrays.asList("aaa", "bb", "c");
List<String> filtered = list.stream()
        .filter(s -> s.length() > 2)
        .collect(Collectors.toList());

Die Logik dieses Codes ist dieselbe wie beim vorherigen Code: Filtern Sie eine Zeichenfolge heraus, deren Länge größer als 2 ist, aus einer Zeichenfolgenliste und speichern Sie sie in einer neuen Liste. Darunter stellt einen Lambda-Ausdruck mit einem Parameter s -> s.length() > 2dar , und sein Funktionskörper ist s.length() > 2.

3. Verwenden Sie Lambda-Ausdrücke, um Mapping-Vorgänge zu vereinfachen

Zusätzlich zu Filtervorgängen müssen wir häufig Zuordnungsvorgänge für Daten durchführen. Normalerweise verwenden wir Schleifen, um die Daten zu durchlaufen und verwenden eine Methode, um die Daten in eine neue Form umzuwandeln. Der folgende Code wandelt beispielsweise alle Zeichenfolgen in einer Zeichenfolgenliste in Großbuchstaben um:

List<String> list = Arrays.asList("aaa", "bb", "c");
List<String> mapped = new ArrayList<String>();
for (String s : list) {
    mapped.add(s.toUpperCase());
}