Java中Lambda表示式的使用詳細教學

2022-05-24 22:05:06

簡介

說明

本文用範例展示Lambda表示式的用法。同時也會介紹Lambda的相關知識。

Lambda表示式介紹

Lambda表示式的本質只是一個"語法糖"，由編譯器推斷並幫你轉換包裝為常規的程式碼，因此你可以使用更少的程式碼來實現同樣的功能。
Lambda表示式是Java SE 8中一個重要的新特性。

Lambda與匿名內部類

Lamda表示式指的是應用在SAM(SingleAbstractMethod,含有一個抽象方法的介面）環境下的一種簡化定義形式。

Lambda比匿名內部類的優點

簡潔（詳見下邊“函數式介面”）

Lamda相對於匿名內部類的缺點

Lamda對應的介面只能有一個方法。
匿名內部類對應的介面可以有多個方法

對介面的要求

1.Lambda 規定介面中只能有一個需要被實現的方法（即抽象方法）。

在一個介面中，後邊幾個可同時存在：一個抽象方法（只能有一個）、多個default方法、多個static方法。

// jdk 8 中有另一個新特性：default，被 default 修飾的方法會有預設實現，不是必須被實現的方法，所以不影響 Lambda 表示式的使用。

2.@FunctionalInterface：用來修飾函數式介面。

@FunctionalInterface寫不寫都可以。此註解主要用於編譯級錯誤檢查：當介面不符合函數式介面定義的時候，編譯器會報錯。

正確例子，沒有報錯：

@FunctionalInterface
public interface HelloWorldService {
    void sayHello(String msg);
}

錯誤例子，報錯：

介面中包含了兩個抽象方法，違反了函數式介面的定義，提示在介面中找到多個非重寫的抽象方法。

注意：加不加 @FunctionalInterface對於介面是不是函數式介面沒有影響，該註解只是提醒編譯器去檢查該介面是否僅包含一個抽象方法。

變數和作用域

Lambda 表示式只能參照標記了 final 的外層區域性變數。即不能在 lambda 內部修改定義在域外的區域性變數，否則編譯報錯
Lambda 表示式的區域性變數可以不用宣告為 final，但是必須不可被後面的程式碼修改（即隱性的具有 final 的語意）
Lambda 表示式中不允許宣告一個與區域性變數同名的引數或者區域性變數。

格式

lambda表示式的重要特徵

可選型別宣告：不需要宣告引數型別，編譯器可以統一識別引數值。
可選的引數圓括號：一個引數無需定義圓括號，但多個引數需要定義圓括號。
可選的大括號：若主體包含了一個語句，就不需要使用大括號。例： () -> Sysout.out.println("Test");
可選的返回關鍵字：若主體只有一個表示式返回值則編譯器會自動返回值，大括號需指定明表示式返回了一個數值。

Lambda 表示式的簡單例子

1. 不需要引數,返回值為 5

() -> 5

2. 接收一個引數(數位型別),返回其2倍的值

x -> 2 * x

3. 接受2個引數(數位),並返回他們的差值

(x, y) -> x – y

4. 接收2個int型整數,返回他們的和

(int x, int y) -> x + y

5. 接受一個 string 物件,並在控制檯列印,不返回任何值(看起來像是返回void)

(String s) -> System.out.print(s)

語法格式

格式：

(parameters) -> statement 或(parameters) ->{ statements; }

左側：Lambda 表示式的參數列

右側：Lambda 表示式中所需要執行的功能（Lambda體）

語法格式一：無引數，無返回值

() -> Sysout.out.println("Test");

語法格式二：有一個引數，並且無返回值

(X)-> Sysout.out.println(x);

語法格式三：如果有一個引數括號可以不寫

X-> Sysout.out.println(x);

語法格式四：有兩個以上的引數，有返回值，並且Lambda體中有多條語句，語法體中需要用{}

    Comparator<Integer> comparator = (o1, o2) -> {
        System.out.println("Test");
        return Integer.compare(o1, o2);
    };

語法格式五：Lambda體中只用一條語句，return和{}可以省略不寫

Comparator comparator = (o1, o2)->Integer.compare(o1, o2);

語法格式六：表示式的參數列的資料型別可以省略不寫，JVM編譯器通過上下文推斷出資料型別

(x ,y ) ->Integer.compare(x ,y)

範例

函數式介面

無引數無返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    void run();
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class: ");
            }
        };
 
        Interface params1 = () -> System.out.println("Lambda: ");
 
        params.run();
        params1.run();
    }
}

執行結果

Anonymous Internal Class:
Lambda:

有引數無返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    void run(String s);
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run(String s) {
                System.out.println("Anonymous Internal Class: " + s);
            }
        };
 
        Interface params1 = (s) -> System.out.println("Lambda: " + s);
 
        params.run("hello");
        params1.run("hi");
    }
}

執行結果

Anonymous Internal Class: hello
Lambda: hi

有引數有返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    String run(String s);
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public String run(String s) {
                System.out.println("Anonymous Internal Class: " + s);
                return "abc";
            }
        };
 
        Interface params1 = (s) -> {
            System.out.println("Lambda: " + s);
            return "def";
        };
 
        System.out.println(params.run("hello"));
        System.out.println(params1.run("hi"));
    }
}

執行結果

Anonymous Internal Class: hello
abc
Lambda: hi
def

lambda作為引數

傳遞一個函數

package org.example.a;
 
interface IRun {
    String welcome(String string);
}
 
class Util {
    public static long executionTime1(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本處刻意新增這一無意義延時，防止執行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
 
    public long executionTime2(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本處刻意新增這一無意義延時，防止執行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
 
    public static String hello(String string){
        String tmp;
        tmp = "hello: " + string;
        return tmp;
    }
 
    public String hi(String string){
        String tmp;
        tmp = "hi: " + string;
        return tmp;
    }
}
 
public class Demo {
    public static void main(String[] args) {
        long time1 = Util.executionTime1(Util::hello, "Tony");
        long time2 = new Util().executionTime2(new Util()::hi, "Pepper");
        System.out.println("time1: " + time1 + "ms");
        System.out.println("time2: " + time2 + "ms");
    }
}

執行結果

hello: Tony
hi: Pepper
time1: 11ms
time2: 11ms

直接傳遞lambda函數

package org.example.a;
 
interface IRun {
    String welcome(String string);
}
 
class Util {
    public static long executionTime(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本處刻意新增這一無意義延時，防止執行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
}
 
public class Demo {
    public static void main(String[] args) {
        long time = Util.executionTime((string -> {
                    String tmp;
                    tmp = "hello: " + string;
                    return tmp;
                })
                , "Tony");
        System.out.println("time: " + time + "ms");
    }
}

執行結果

hello: Tony
time: 11ms

遍歷集合

package org.example.a;
 
import java.util.ArrayList;
import java.util.List;
 
public class Demo{
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
 
        //以前的迴圈方式
        for (String string : list) {
            System.out.println(string);
        }
 
        //使用lambda表示式輸出list中的每個值
        list.forEach(c->{
            System.out.println(c);
        });
 
        // 在 Java 8 中使用雙冒號操作符(double colon operator）。也屬於lamda表示式
        list.forEach(System.out::println);
    }
}

執行結果

aaa
bbb
aaa
bbb
aaa
bbb

建立執行緒

package org.example.a;
 
public class Demo{
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class !");
            }
        }).start();
 
        new Thread(() -> System.out.println("Lambda !")).start();
    }
}

執行結果

Anonymous Internal Class !
Lambda !

排序

package org.example.a;
 
import java.util.Arrays;
import java.util.Comparator;
 
public class Demo{
    public static void main(String[] args) {
        String[] players = {"Rafael Nadal", "Novak Djokovic", "Stanislas Wawrinka"};
        
        Arrays.sort(players, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return (o1.compareTo(o2));
            }
        });
 
//        Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));
//        Arrays.sort(players, sortByName);
        
//        Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));
        
        for(String string:players){
            System.out.println(string);
        }
    }
}

執行結果（換成註釋掉的兩種任意一種都是一樣的）

Novak Djokovic
Rafael Nadal
Stanislas Wawrinka

以上就是Java中Lambda表示式的使用詳細教學的詳細內容，更多關於Java Lambda表示式的資料請關注it145.com其它相關文章！

Java中Lambda表示式的使用詳細教學

目錄

簡介

格式

範例

函數式介面

lambda作為引數

遍歷集合

建立執行緒

排序

熱門文章