Eine kurze Analyse von Lambda-Ausdrücken und neuen Funktionen von Java 8

Wenn man über Java 8 spricht, fallen mir als Erstes Lambda (Abschluss) und die virtuelle Erweiterungsmethode (Standardmethode) ein. Diese Funktion wurde bereits von großen Technologie-Websites hochgelobt und ist auch das Erste, was wir tun Wir werden zu Beginn unserer Java 8-Serie (JEP126 http://openjdk.java.net/jeps/126) darüber sprechen, dass einige Bibliotheken von jdk8 mithilfe von Lambda-Ausdrücken neu gestaltet wurden neue Funktionen von Java 8.

1. Funktionsschnittstelle

Funktionsschnittstelle (Funktionsschnittstelle wird auch Funktionsschnittstelle genannt, ist aber eigentlich dasselbe). Einfach ausgedrückt ist eine funktionale Schnittstelle eine Schnittstelle, die nur eine Methode enthält. Beispielsweise sind java.lang.Runnable und java.util.Comparator in der Java-Standardbibliothek typische Funktionsschnittstellen. Java 8 stellt @FunctionalInterface als Annotation bereit. Solange die Schnittstelle den Standards funktionaler Schnittstellen entspricht (d. h. eine Schnittstelle, die nur eine Methode enthält), wird sie von der virtuellen Maschine automatisch ermittelt Verwenden Sie am besten die Annotation @FunctionalInterface für die Schnittstelle. Dadurch wird verhindert, dass andere Mitglieder des Teams versehentlich neue Methoden zur Schnittstelle hinzufügen.
Lambda kann in Java nicht alleine angezeigt werden. Der Körper der Lambda-Ausdrucksmethode ist eigentlich die Implementierung der funktionalen Schnittstelle > 2. Lambda-Syntax

Enthält drei Teile

1. Ein durch Kommas in Klammern getrennter Parameter. Der Parameter ist der Parameter der Methode in der Funktionsschnittstelle.

2 . Ein Pfeilsymbol:- >

3. Der Methodenkörper kann ein Ausdruck oder ein Codeblock sein muss mit {} umschlossen werden und ein Rückgabewert ist erforderlich, es gibt jedoch eine Ausnahme. Wenn der Rückgabewert der Methode in der funktionalen Schnittstelle ungültig ist, besteht keine Notwendigkeit ist wie folgt:

(parameters) -> expression 或者 (parameters) -> { statements; }

/**
 * 测试lambda表达式
 *
 * @author benhail
 */
public class TestLambda {
    public static void runThreadUseLambda() {
        //Runnable是一个函数接口，只包含了有个无参数的，返回void的run方法；
        //所以lambda表达式左边没有参数，右边也没有return，只是单纯的打印一句话
        new Thread(() ->System.out.println("lambda实现的线程")).start(); 
    }
    public static void runThreadUseInnerClass() {
        //这种方式就不多讲了，以前旧版本比较常见的做法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("内部类实现的线程");
            }
        }).start();
    }
    public static void main(String[] args) {
        TestLambda.runThreadUseLambda();
        TestLambda.runThreadUseInnerClass();
    }
}

ist eigentlich eine vereinfachte Methode zum Schreiben des Lambda-Ausdrucks. Die Syntax ist ebenfalls sehr einfach Der Container (kann der Klassenname und der Instanzname sein), in der Mitte befindet sich „::“ und rechts der entsprechende Methodenname. Wie unten gezeigt:

ObjectReference::methodName

Wenn es sich um eine Instanzmethode handelt, ist es Instance::methodName. Zum Beispiel: Object obj=new Object();obj::equals;

Konstruktor. Dann ist es ClassName::new

Schauen wir uns zum besseren Verständnis ein vollständiges Beispiel an:

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
/**
 *
 * @author benhail
 */
public class TestMethodReference {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        frame.setLayout(new FlowLayout());
        frame.setVisible(true);

        JButton button1 = new JButton("点我!");
        JButton button2 = new JButton("也点我!");

        frame.getContentPane().add(button1);
        frame.getContentPane().add(button2);
        //这里addActionListener方法的参数是ActionListener，是一个函数式接口
        //使用lambda表达式方式
        button1.addActionListener(e -> { System.out.println("这里是Lambda实现方式"); });
        //使用方法引用方式
        button2.addActionListener(TestMethodReference::doSomething);

    }
    /**
     * 这里是函数式接口ActionListener的实现方法
     * @param e 
     */
    public static void doSomething(ActionEvent e) {

        System.out.println("这里是方法引用实现方式");

    }
}

Das Obige ist der gesamte Inhalt der Lambda-Ausdruckssyntax. Ich glaube, jeder hat ein gewisses Verständnis für Lambda-Ausdrücke, aber wenn der Code einfach ist, wird er viele Zuschauer nicht beeindrucken . Java 8 Es ist nicht so aufregend, Lambda in Java 8 einzuführen, da Lambda-Ausdrücke die Multithread- oder Multi-Core-Verarbeitung von Daten in Sammlungen vereinfachen und eine schnellere Verarbeitungsgeschwindigkeit ermöglichen können wird später auf JEP126 besprochen. Der Grund für die Trennung ist, dass es zu viele Dinge gibt, um über diese Funktion zu schreiben. Dieser Teil macht die Leser mit der Syntax und den Konzepten von Lambda-Ausdrücken vertraut Der zweite Teil befasst sich mit virtuellen Erweiterungsmethoden (Standardmethode). Im letzten Teil geht es um die Verarbeitung großer Datensammlungen, um das Geheimnis der stärksten Wirkung von Lambda-Ausdrücken zu lüften.

Weitere Artikel zur Analyse von Lambda-Ausdrücken und den neuen Funktionen von Java 8 finden Sie auf der chinesischen PHP-Website!