一起來了解Java的Lambda表示式

2022-03-14 19:02:05

Lambda表示式：

1、簡介

首先Lambda表示式是屬於Java8的一個新特性，提供Java程式設計中對於函數語言程式設計的支援，有助於程式碼的簡潔，可以取代大半部分的匿名函數，尤其對於集合的遍歷和集合的操作，極大的簡化了程式碼。

Lambda表示式的主體：

函數式介面：

注意： Lambda表示式一定要配合函數式介面一起使用，所謂函數式介面，就是介面中只有一個抽象方法的介面就是函數式介面，我們可以自定義，JDK也內建了大量的函數式介面。

1、@FunctionalInterface註解修飾了介面，那這個介面就是函數式介面，只能有一個方法，下面就是一個函數式介面：

@FunctionalInterface
public interface MyInteface {
    void eat();
}

2、如果不加@FunctionalInterface**註解，你在介面裡面只寫一個抽象方法也可以認為是函數式介面：

public interface MyInteface {
    void eat();
}

這樣也是可以的。

3、函數式介面只有一種情況不只有抽象方法，那就是可以繼承Object類的方法：

@FunctionalInterface
public interface MyInteface3 {
    void eat();
    @Override
    String toString();
    @Override
    int hashCode();
}

2、Lambda表示式的使用：

1、在普通方法內的使用

Student類：

@FunctionalInterface
public interface Student {
    void eat();
}

測試類：

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();
    }
}

輸出：

我是學生
學生吃飯

2、帶參方法的使用

Student類：

@FunctionalInterface
public interface Student {
    void eat(String food);
}

測試類：

public class Test {
    public static void main(String[] args) {
        //lambda重寫Student介面唯一的有參方法：
        Student stu2 = (foodName)->{
            System.out.println("學生在吃"+foodName);
        };
        stu2.eat("肉");
    }
}
//輸出：學生在吃肉

3、Lambda表示式實現多執行緒

之前在多執行緒（1）的那篇文章內有介紹了建立多執行緒的方法，這裡就使用lambda來建立執行緒：

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("這個執行緒是由lambda來建立的");
        });
        t.start();
    }
}

4、Lambda表示式操作運算

我們使用lambda來操作運算可以少很多程式碼：

函數式介面：

@FunctionalInterface
public interface Calculator<T> {
    T operation(T v1,T v2);
}

測試類：

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);
    }
}

輸出：

15 、15 、5

5、Lambda表示式方法參照

有時候我們不是必須要要重寫介面的方法來做具體的實現，我們如果有存在的方法能來實現，也可以通過方法參照的方式來參照已經存在的方法做介面中方法具體的實現，這樣的好處就是程式碼複用，比如下面這樣：

函數式介面：

public interface ResultOneParam {
    int method(int a);
}

測試類：

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、Lambda表示式對集合的使用

當然Lambda對集合的操作也是很方便的，可以少些很多程式碼：

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);
            }
        });
    }
}