Beispielanalyse eines Java-Lambda-Ausdrucks

1. Einführung

Zuallererst ist der Lambda-Ausdruck eine neue Funktion von Java8. Er bietet Unterstützung für die funktionale Programmierung, hilft bei der Vereinfachung des Codes und kann die meisten anonymen Funktionen ersetzen, insbesondere für Sammlungsdurchquerung und Sammlungsoperationen vereinfachen den Code erheblich.

Der Hauptteil des Lambda-Ausdrucks:

Funktionale Schnittstelle:

Hinweis: Der Lambda-Ausdruck muss mit einer funktionalen Schnittstelle verwendet werden. Die sogenannte funktionale Schnittstelle bedeutet, dass eine Schnittstelle mit nur einer abstrakten Methode in der Schnittstelle funktionsfähig ist Wir können die Schnittstelle anpassen, und JDK verfügt auch über eine große Anzahl integrierter Funktionsschnittstellen.

1. Die Annotation @FunctionalInterface ändert die Schnittstelle, dann ist diese Schnittstelle eine funktionale Schnittstelle, die nur eine Methode haben kann:

@FunctionalInterface
public interface MyInteface {

    void eat();

}

2 , Sie befinden sich in der Schnittstelle. Das Schreiben nur einer abstrakten Methode kann auch als funktionale Schnittstelle betrachtet werden:

public interface MyInteface {
    void eat();
}

Das ist auch möglich.

3. Es gibt nur einen Fall, in dem funktionale Schnittstellen mehr als abstrakte Methoden haben, und das ist die Methode, die die Object-Klasse erben kann:

@FunctionalInterface
public interface MyInteface3 {

    void eat();

    @Override
    String toString();
    
    @Override
    int hashCode();
}

2. Die Verwendung in gewöhnlichen Methoden

Studentenklasse:

@FunctionalInterface
public interface Student {

    void eat();

}

Testklasse:

public class Test {
    public static void main(String[] args) {

        Student stu = new Student() {

            //普通方法，重写并使用
            @Override
            public void eat() {
                System.out.println("我是学生");
            }
        };
        stu.eat();


        //lambda表达式写法：
        //参数1:重写了Student接口中唯一的那个无参数的eat抽象方法做了具体的实现，所以重写不 需要署名
        //参数2:-> 表达式 固定的
        //参数3：{具体的实现} 对Student接口中唯一的eat方法做了具体的实现
            Student stu2 = () -> {
                System.out.println("学生吃饭");
            };
        stu2.eat();
        
    }
}

Ausgabe:

Ich bin Student

Studenten essen

2. Verwendung von Methoden mit Parametern

Studentenklasse:

@FunctionalInterface
public interface Student {

    void eat(String food);
}

Testklasse:

public class Test {
    public static void main(String[] args) {

        //lambda重写Student接口唯一的有参方法：
        Student stu2 = (foodName)->{
            System.out.println("学生在吃"+foodName);
        };

        stu2.eat("肉");
    }
}

//Ausgabe: Schüler essen Fleisch

3. Lambda-Ausdrücke zur Implementierung von Multithreading

Die Methode zum Erstellen von Multithreads wurde im Artikel über Multithreading (1) vorgestellt. Hier verwenden wir Lambda zum Erstellen von Threads :

public class Test {
    public static void main(String[] args) {

        Thread t = new Thread(() -> {
            System.out.println("这个线程是由lambda来创建的");
        });

        t.start();

    }
}

4, Lambda-Ausdrucksoperationsoperationen

Wir können Lambda zum Betreiben von Operationen verwenden und viel Code sparen:

Funktionsschnittstelle:

@FunctionalInterface
public interface Calculator<T> {

    T operation(T v1,T v2);

}

Testklasse:

public class Test {

    //计算方法
    public static Integer operator(Integer v1,Integer v2,Calculator<Integer> calculator){
        return calculator.operation(v1, v2);
    }

    public static void main(String[] args) {


        //使用lambda表达式：
        //这里的意思就是传入两个参数，返回运行后的值
        int add = Test.operator(5,10,(x,y)->{
            return x+y;
        });


        //简写：可以少写很多代码，比上面更简介了
        int num1 = Test.operator(5,10,(x,y)->x+y);
        int num2 = Test.operator(10,5,(x,y)->x-y);

        System.out.println(add);
        System.out.println(num1);
        System.out.println(num2);

    }
}

Ausgabe:

15, 15, 5

5, Referenz zur Lambda-Ausdrucksmethode

Manchmal müssen wir die Schnittstellenmethode nicht neu schreiben, um eine bestimmte Implementierung zu erreichen. Wenn wir eine vorhandene Methode zur Implementierung haben, können wir auch über die Methode auf die vorhandene Methode in der Schnittstelle verweisen Referenz. Der Vorteil der spezifischen Implementierung der Methode ist die Wiederverwendung von Code, wie zum Beispiel die folgende:

Funktionsschnittstelle:

public interface ResultOneParam {

    int method(int a);
}

Testklasse:

public class Test {

    public int addTo(int a){
        return  a+10;
    }

    public  static int addTo2(int a){
        return  a+10;
    }

    public static void main(String[] args) {
        //lambda重写了method方法
        ResultOneParam lambda1=(a)->a+10;

        //方法引用：就是在Test里面的addTo2方法用来替代method被重写的方法
        ResultOneParam lambda2= Test::addTo2;
        int result1= lambda2.method(9);
        System.out.println(result1);

        //方法引用 ::引用现成的方法来替代方法重写，这样可以方法重用
        Test test=new Test();
        ResultOneParam lambda3=test::addTo;
        int result2= lambda3.method(9);
        System.out.println(result1);

    }
}

6. Die Verwendung von Lambda-Ausdrücken für Sammlungen

Natürlich auch Lambda Arbeitet mit Sammlungen. Sehr praktisch und spart viel Code:

public class Test {
    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(5,1,3,4,5,0,9,7,0,1,5);

        //lambda表达式遍历集合，重写了Consumer接口的方法
        list.forEach((element)->{
            System.out.println(element);
        });

        //简写：
        list.forEach(element-> System.out.println(element));

        //lambda表达式方法引用，用于遍历输出list集合:
        list.forEach(System.out::print);

        //输出list的偶数:
        list.forEach(element->{
            if(element%2==0){
                System.out.println(element);
            }

        });
    }
}

Das obige ist der detaillierte Inhalt vonBeispielanalyse eines Java-Lambda-Ausdrucks. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!