Java中Lambda表達式的使用詳細教程

Posted on 2022-05-24 by WalkonNet

簡介

說明

本文用示例展示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表達式的資料請關註WalkonNet其它相關文章！

Java中Lambda表達式的使用詳細教程

目錄

簡介

格式

實例

函數式接口

lambda作為參數

遍歷集合

創建線程

排序

推薦閱讀：

發佈留言取消回覆

近期文章

目錄

簡介

格式

實例

函數式接口

lambda作為參數

遍歷集合

創建線程

排序

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆