Eine kurze Analyse von Lambda-Ausdrücken in Java 8: Warum Lambda-Ausdrücke verwenden?

Der Inhalt dieses Artikels ist eine kurze Analyse von Lambda-Ausdrücken in Java 8: Warum Lambda-Ausdrücke verwendet werden sollten. Ich hoffe, dass er für Sie hilfreich ist.

Lambda-Ausdrücke sind die beliebteste Funktion von Java8. Die Menschen führten das Konzept der funktionalen Programmierung in Java ein, einer vollständig objektorientierten imperativen Programmiersprache.

Was die Funktionsweise der funktionalen Programmierung angeht, geht dieses Thema über den Rahmen dieses Artikels hinaus, aber wir werden eine seiner Funktionen extrahieren, die sich offensichtlich von der OOP (objektorientierten Programmierung) unterscheidet, die wir oft diskutieren.

In diesem Artikel erfahren wir, was genau Lambda-Ausdrücke sind und wie sie sich in das gesamte Java-Ökosystem einfügen. Wir werden auch den Code beobachten und vergleichen, der keine Lambda-Ausdrücke verwendet, und den Beispielcode, der später mit Lambda umgestaltet wird.

Lambda-Ausdrücke verstehen

Ein Lambda-Ausdruck ist ein Codestück, das wir übergeben und ausführen können. Als Java-Programmierer sind wir es nicht gewohnt, einen Codeabschnitt an eine Funktion zu übergeben. Unsere Gewohnheit besteht darin, den definierten Code in den Methodenkörper zu kapseln und ihn dann über Objektreferenzen auszuführen, wie unten gezeigt:

public class LambdaDemo {
    public void printSomething(String something) {
        System.out.println(something);
    }
    public static void main(String[] args) {
        LambdaDemo demo = new LambdaDemo();
        String something = "I am learning Lambda";
        demo.printSomething(something);
    }
}

Dies ist der klassische Stil des OOP-Entwicklungsparadigmas verbirgt die Methodenimplementierung vor Aufrufern. Der Aufrufer übergibt einfach eine Variable an die Methode, und dann führt die Methode einige Operationen an der Variablen aus und gibt einen anderen Variablenwert zurück oder erzeugt, wie in unserem Beispiel, einige Nebenwirkungen.

Jetzt schauen wir uns eine äquivalente Implementierung an, die Verhaltensübergabe anstelle von Variablenübergabe verwendet. Dazu müssen wir eine funktionale Schnittstelle erstellen, die das Verhalten und nicht die Abstraktion von Methoden definiert. Eine funktionale Schnittstelle ist eine Schnittstelle mit nur einer Methode:

public class LambdaDemo {
    interface Printer {
        void print(String val);
    }
    public void printSomething(String something, Printer printer) {
        printer.print(something);
    }
}

In der obigen Codeimplementierung ist die Druckerschnittstelle für alle Druckvorgänge verantwortlich. Die printSomething-Methode definiert kein Verhalten mehr, sondern führt das durch Printer definierte Verhalten aus:

public static void main(String[] args) {
    LambdaDemo demo = new LambdaDemo();
    String something = "I am using a Functional interface";
    Printer printer = new Printer() {
        @Override
        public void print(String val) {
            System.out.println(val);
        }
    };
    demo.printSomething(something, printer);
}

Aufmerksamere Leser haben vielleicht bemerkt, dass hier nichts Neues getan wird. Das stimmt, weil ich es noch nicht auf Lambda-Ausdrücke angewendet habe. Wir erstellen einfach eine konkrete Implementierung der Druckerschnittstelle und übergeben sie an die printSomething-Methode.

Das obige Beispiel soll uns ein wichtiges Ziel der Einführung von Lambda-Ausdrücken in Java näher bringen:

Lambda-Ausdrücke wurden ursprünglich verwendet, um eine Inline-Implementierung einer funktionalen Schnittstelle zu definieren

Vorher Wir rekonstruieren das obige Beispiel mithilfe von Lambda-Ausdrücken und erlernen die erforderlichen Syntaxkenntnisse:

(param1,param2,param3...,paramN) - > {//代码块;}

a Die Zusammensetzung eines Lambda-Ausdrucks ist eine in Klammern und eingeschlossene Parameterliste durch Kommas getrennt, die wir normalerweise in einer Methodendeklaration definieren, gefolgt von einem Pfeil, der auf den auszuführenden Code zeigt. Lassen Sie uns nun den obigen Code mit Lambda umgestalten:

public static void main(String[] args) {
    LambdaDemo demo = new LambdaDemo();
    String something = "I am learning Lambda";
    /**/
    Printer printer = (String toPrint)->{System.out.println(toPrint);};
    /**/
    demo.printSomething(something, printer);
}
}

Sieht sehr kompakt und schön aus. Da die funktionale Schnittstelle nur eine Methode deklariert, werden die im ersten Teil des Lambda übergebenen Parameter automatisch der Parameterliste der Methode zugeordnet und der Code rechts vom Pfeil wird als spezifische Implementierung der Methode betrachtet.

Warum Lambda-Ausdrücke verwenden?

Wie im vorherigen Beispiel ermöglichen uns Lambda-Ausdrücke einen kompakteren Code, der leichter zu lesen und zu befolgen ist. Dieser Ansatz bietet weitere Vorteile in Bezug auf Leistung und Multi-Core-Verarbeitung, diese gelten jedoch erst, wenn Sie die Streams-API verstanden haben, was den Rahmen dieses Artikels sprengen würde.

Durch den Vergleich der Hauptmethode mit und ohne Lambda können wir, wenn sie den Code plötzlich verkürzt, tatsächlich die Leistungsfähigkeit von Lambda-Ausdrücken erkennen:

public static void main(String[] args) {
    LambdaDemo demo = new LambdaDemo();
    String something = "I am learning Lambda";
    /**/
    Printer printer = (String toPrint)->{System.out.println(toPrint);};
    /**/
    demo.printSomething(something, printer);
}

Wir können den Code auch prägnanter gestalten als hier gezeigt. In diesem Fall müssen Sie nicht einmal den Typ des Parameters auf der linken Seite des Pfeils angeben, und sein Typ wird vom Compiler basierend auf den formalen Parametern der Schnittstellenmethode abgeleitet.

Printer printer = (toPrint)->{System.out.println(toPrint);};

Wir können es besser machen. Ein weiteres Merkmal von Lambda besteht darin, dass die Klammern vollständig entfernt werden können, wenn nur ein Parameter vorhanden ist. Wenn rechts vom Pfeil nur eine Anweisung steht, können Sie auch die geschweiften Klammern entfernen:

Printer printer = toPrint -> System.out.println(toPrint);

Jetzt sieht der Code wirklich süß aus, aber Wir Es ist erst der Anfang. Wenn unsere Schnittstellenmethode keine Parameter erfordert, können wir das Leben durch ein leeres Klammerpaar ersetzen:

() -> System.out.println("anything");

Wenn wir nur ein Lambda einbinden. Was wäre, wenn wir Gehen Sie hinein, ohne zuerst ein Objekt zu erstellen und es an die saySomething-Methode zu übergeben:

public static void main(String[] args) {
    LambdaDemo demo = new LambdaDemo();
    String something="I am Lambda";    /**/
    demo.printSomething(something, toPrint -> System.out.println(toPrint));
}

Jetzt reden wir wirklich über funktionale Programmierung. Unser Hauptfunktionskörper wurde von 9 Codezeilen auf 3 Zeilen reduziert. Solch kompakter Code macht Lambda-Ausdrücke für Java-Programmierer sehr attraktiv.

Das obige ist der detaillierte Inhalt vonEine kurze Analyse von Lambda-Ausdrücken in Java 8: Warum Lambda-Ausdrücke verwenden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!