2. 程式人生 > 其它 >java8_Lambda表示式詳解

java8_Lambda表示式詳解

阿新 • • 發佈：2021-01-17

技術標籤：javajavalambda

Lambda表示式

1. 什麼是Lambda表示式？

Lambda表示式是java8的新特性，是一個匿名函式。
java8為了實現lambda表示式對介面進行了修改，java8之前介面只能全部是抽象方法，但是為了實現lambda表示式對其進行了修改。
java8之後介面可以實現預設的方法，即default修飾的方法可以在介面中實現。

2. 為什麼要使用Lambda表示式？

使用Lambda表示式可以對介面進行非常簡潔的實現（就是為了實現介面的）。

3. Lambda表示式對介面的要求？

介面中只能有一個未被實現的方法。
在jdk中用 @FunctionalInterface

定義的介面都是可以使用lambda表示式實現匿名函式的。
如：
@FunctionalInterface
public interface Comparator

4. Lambda表示式基礎語法

普通方法的語法關注：
返回值型別 方法名 引數型別 方法體
Lambda表示式語法關注：
lambda表示式是匿名函式，即不關注方法名；
lambda表示式的返回值型別不用顯示的寫出來；
所以：lambda表示式只關注：引數列+方法體
() : 用來描述引數列名（即普通方法的形式引數）
{ } : 用來描述方法體（和普通方法的方法體相同）
-> : 用來描述引數列名和方法體的關聯
lambda表示式的基本語法是：（）-> { }

5. Lambda的基本使用
  1. 無參無返回值的介面實現
class LambdaTest01 {
    public static void main(String[] args) {
        Interface i = () -> { System.out.println("hello word"); };
        i.say();
    }
}
interface Interface{
    void say();
}
//輸出：hello word
  1. 無參有返回值
public class LambdaTest02 {
    public
 
 static void main(String[] args) {
        Interface02 i = () -> {
            return 10;
        };
        int a = i.say();
        System.out.println(a);
    }
}

interface Interface02 {
    int say();
}
//輸出：10
  1. 有一個引數，無返回值
public class LambdaTest03 {
    public static void main(String[] args) {
        Interface03 i = (int a) -> {
            System.out.println(a);
        };
        i.sum(10);
    }
}

interface Interface03 {
    void sum(int a);
}
//輸出：10
  1. 有一個引數，有返回值
public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i = (int a) -> {
            return a * 2;
        };
        System.out.println(i.sum(10));
    }
}

interface Interface04 {
    int sum(int a);
}
//輸出：20
  1. 有多個引數無返回值
public class LambdaTest05 {
    public static void main(String[] args) {
        Interface05 i = (int a, int b) -> {
            System.out.println(a + b);
        };
        i.sum(10, 20);
    }
}

interface Interface05 {
    void sum(int a, int b);
}
//輸出：30
  1. 有多個引數有返回值
public class LambdaTest06 {
    public static void main(String[] args) {
        Interface06 i = (int a, int b) -> {
            return a + b;
        };
        System.out.println(i.sum(10, 20));
    }
}

interface Interface06 {
    int sum(int a, int b);
}
6.Lambda表示式的精簡
  1. 如果表示式中有引數，可以省略引數的引數型別
public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i = (a) -> {
            return a * 2;
        };
        System.out.println(i.sum(10));
    }
}

interface Interface04 {
    int sum(int a);
}

(如果有多個引數，則全部引數的型別都必須省略)

public class LambdaTest06 {
    public static void main(String[] args) {
        Interface06 i = (a, b) -> {
            return a + b;
        };
        System.out.println(i.sum(10, 20));
    }
}

interface Interface06 {
    int sum(int a, int b);
}
  1. 如果表示式中的引數個數只有一個，小括號可以省略
public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i = a -> {
            return a * 2;
        };
        System.out.println(i.sum(10));
    }
}

interface Interface04 {
    int sum(int a);
}
//輸出：10
  1. 如果表示式中的方法體只有一條執行語句，大括號可以省略
  2. 如果表示式中的方法體中的一條語句是return語句，大括號和return要一起省略
public class LambdaTest03 {
    public static void main(String[] args) {
        Interface03 i = a -> System.out.println(a);
        i.sum(10);
    }
}

interface Interface03 {
    void sum(int a);
}

public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i = a ->
                a * 2;

        System.out.println(i.sum(10));
    }
}

interface Interface04 {
    int sum(int a);
}
7.方法引用

如：

public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i1 = a -> a * 2;
		Interface04 i2 = a -> a * 2;
		Interface04 i3 = a -> a * 2;
       	System.out.println(i1.sum(10) + i2.sum(20) + i3.sum(30));
    }
}

interface Interface04 {
    int sum(int a);
}

當程式的多個地方要用到實現都是一樣的，那麼就可以抽出一個方法去實現:
方法的引數必須和介面中的抽象方法引數相同

public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i1 = a -> chage(a);
        Interface04 i2 = a -> chage(a);
        Interface04 i3 = a -> chage(a);

        System.out.println(i1.sum(10) + i2.sum(20) + i3.sum(30));
    }

    private static int chage(int a) {
        return a * 2;
    }
}

interface Interface04 {
    int sum(int a);
}
8.構造方法的引用

Person類

class Person {
    public String name;
    public int age;

    public Person() {
        System.out.println("使用的Person的無參構造");
    }

    public Person(String name, int age) {
        System.out.println("使用的Person的有參構造");
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

獲取Person物件的抽象方法

interface PersonCreate {
    Person getPerson();
}

測試類（原始的Lambda表示式）

public class LambdaTest07 {
    public static void main(String[] args) {
        PersonCreate p = () -> {
            return new Person();
        };
        p.getPerson();
    }

}

語法精簡

PersonCreate p = () -> {  return new Person(); };

只有一條語句（省略大括號和return語句）：

PersonCreate p = () -> new Person();

再次精簡：
構造方法的引用（類名::new）

PersonCreate p = Person::new ;

測試一下是否可以獲得person物件
測試類：

public class LambdaTest07 {
    public static void main(String[] args) {
        PersonCreate p = Person::new ;
        p.getPerson();
    }
}
//列印：使用的Person的無參構造

兩參構造一樣，只是獲取物件介面中引數和構造方法中的引數要相同
修改介面：

interface PersonCreate {
    Person getPerson(String name, int age);
}

測試類:

public class LambdaTest07 {
    public static void main(String[] args) {
        PersonCreate p = Person::new;
        p.getPerson("zhangsan", 20);
    }

}
//列印：使用的Person的有參構造
9.在集合中的使用

還是使用Person類

class Person {
    public String name;
    public int age;

    public Person() {
        //System.out.println("使用的Person的無參構造");
    }

    public Person(String name, int age) {
        //System.out.println("使用的Person的有參構造");
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

將person物件加入到list集合

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        
    }
}

使用list.sort( )排序,根據年齡從大到小排序

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        list.sort((o1, o2) -> o2.age - o1.age);
        System.out.println(list);
    }
}
//輸出：
[Person{name='lisi', age=20}, Person{name='zhangsan', age=18}, Person{name='wangwu', age=18}, Person{name='xianoming', age=16}]

用list.forEach( )方法，遍歷集合（System.out::println）

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        list.sort((o1, o2) -> o2.age - o1.age);
        //System.out.println(list);
        list.forEach(System.out::println);
    }
}
//輸出：
Person{name='lisi', age=20}
Person{name='zhangsan', age=18}
Person{name='wangwu', age=18}
Person{name='xianoming', age=16}

刪除集合元素，如果用foreach遍歷刪除，會報錯
如：

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        list.sort((o1, o2) -> o2.age - o1.age);
        //System.out.println(list);
        //list.forEach(System.out::println);
        for(Person p : list){
            if(p.age>18){
                list.remove(p);
            }
        }
    }
}
//報錯資訊：
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at com.java.LambdaTest08.main(LambdaTest08.java:16)
（具體資訊百度可以處理，這裡不多解釋，繼續）

如果想實現刪除可以用迭代器，或者從0 ~ size - 1 遍歷元素
lambda可以使用list.removeIf( )刪除集合元素

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        list.sort((o1, o2) -> o2.age - o1.age);
        //System.out.println(list);
        //list.forEach(System.out::println);
        /*for(Person p : list){
            if(p.age>18){
                list.remove(p);
            }
        }*/
        list.removeIf(person -> person.age >18);
        list.forEach(System.out::println);
    }
}
//輸出：
Person{name='zhangsan', age=18}
Person{name='wangwu', age=18}
Person{name='xianoming', age=16}
（刪除成功）
10.線上程中的使用

使用lambda前

public class LambdaTest09 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("啟動執行緒");
            }
        });
        t.start();
    }
}
//輸出：執行緒啟動

使用lambda後

public class LambdaTest09 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> System.out.println("執行緒啟動"));//因為只有一句話，簡寫
        t.start();
    }
}
//輸出：執行緒啟動
11.系統內建函式式介面

jdk系統內部也封裝了好多可以用Lambda表示式去實現的介面
Predicate(引數T；返回值boolean）（子類IntPredicate、LongPredicate、DoublePredicate)、
Consumer(引數T；返回值void)(子類IntConsumer、LongConsumer、DoubleConsumer)、
Function<T,R>（引數T；返回值R）、
Supplier(引數無；返回值T)、
UnaryOperator<T,T>(引數T；返回值T)、
BinaryOperator<T,T>(引數T，T；返回值T)、
BiFunction<T,U,R>(引數T，U；返回值R)、
BiPredicate<T,U>(引數T，U；返回值boolean)、
BiConsumer<T,U>(引數T，U；返回值void)）

public class LambdaTest10 {
    public static void main(String[] args) {
    
        int n = getNumber().get();
        
        System.out.println(n);
    }

    private static Supplier<Integer> getNumber() {
        int num = 10;
        return () -> {
            return num;
        };
    }
}
//輸出：10

public class LambdaTeat11 {
    public static void main(String[] args) {
        int a = 10;//注意：這個a會提升至final ,不可以執行++或其他操作

        Consumer<Integer> c = ele ->{
            System.out.println(a);
        };
        
        c.accept(1);
    }
}
//輸出：10

總結：Lambda表示式可以減少程式碼冗餘，提高程式碼的執行效率。

相關推薦

java8_Lambda表示式詳解

技術標籤：javajavalambda Lambda表示式 1. 什麼是Lambda表示式？ Lambda表示式是java8的新特性，是一個匿名函式。 java8為了實現lambda表示式對介面進行了修改，java8之前介面只能全部是抽象方法，但是為了實現

python中Lambda表示式詳解

如果你在學校讀的是電腦科學專業，那麼可能學過 Lambda 表示式， 不過可能從來沒有用過它。如果你不是電腦科學專業，它們看著可能 有點兒陌生（或者只是“曾經學習過的東西”）。在這一節裡，雖然我們 不打算深入學習

Quartz.Net系列（九）：Trigger之CronScheduleBuilder和Cron表示式詳解

1.使用 var scheduler =await StdSchedulerFactory.GetDefaultScheduler(); await scheduler.Start(); var job = JobBuilder.Create<FirstJob>().Build();

Nginx的正則表示式詳解

Nginx (engine x) 是一個高效能的HTTP和反向代理服務，也是一個IMAP/POP3/SMTP服務。Nginx是由伊戈爾·賽索耶夫為俄羅斯訪問量第二的Rambler.ru站點（俄文：Рамблер）開發的，第一個公開版本0.1.0釋出於2004年

python 正則表示式詳解

　正則表示式是一個很強大的字串處理工具，幾乎任何關於字串的操作都可以使用正則表示式來完成，作為一個爬蟲工作者，每天和字串打交道，正則表示式更是不可或缺的技能，正則表示式的在不同的語言中使用方式可能不一

Lambda表示式詳解

轉載 https://www.cnblogs.com/haixiang/p/11029639.html Lambda簡介 Lambda 表示式是 JDK8 的一個新特性，可以取代大部分的匿名內部類，寫出更優雅的 Java 程式碼，尤其在集合的遍歷和其他集合操作中，可以極大地優

jsp EL表示式詳解

一、EL表示式介紹 Expression Language表示式語言 是一種在JSP頁面獲取資料的簡單方式(只能獲取資料，不能設定資料)

正則表示式詳解（上）

簡單來說，正則表示式是根據一定的語法規則組合而成的用來匹配具有某種模式的文字的字串。

正則表示式詳解（下）

書接上文，在下篇中主要介紹如何在 python 中使用正則表示式實現文字的匹配和替換工作。

EL表示式詳解_javaweb_jsp

技術標籤：java 1.EL表示式介紹 Expression Language表示式語言 是一種在JSP頁面獲取資料的簡單方式(只能獲取資料，不能設定資料) 在JSP2.0開始引入概念

C# LINQ和Lambda表示式詳解

(1) 簡單的查詢語句 Linq語法： var data=from a in db.Areas select a ; Lamda語法： var data=db.Areas;

報表系統 表示式詳解

單元格表示式 單元格表示式直接在單元格中定義，例如：=sum(A1:A2)，類似MS Excel計算公式。當前版本支援以下函式：

shell指令碼中的正則表示式詳解

正則表示式的概念及特點： 　　正則表示式是對字串操作的一種邏輯公式，就是用事先定義好的一些特定字元、及這些特定字元的組合，組成一個“規則字串”，

正則表示式詳解

1、正則表示式構成 ​ 簡介：描述了一種字串匹配的模式，可以用來檢查一個串是否含有某種子串、將匹配的子串替換或者從某個串中取出符合某個條件的子串等。

Cron表示式詳解

Cron表示式是一個字串，字串以5或6個空格隔開，分為6或7個域，每一個域代表一個含義，Cron有如下兩種語法格式：

JavaScript 正則表示式詳解

目錄1. 正則表示式建立2. 使用模式2.1 使用簡單模式2.2 使用特殊字元3. 應用3.1 切分字串3.2 分組3.3 貪婪匹配3.4 正則表示式標誌3.5 test() 方法4. 常用正則（參考）總結1. 正則表示式建立

vue基礎語法之插值表示式詳解

目錄一、vscode外掛介紹二、插值表示式介紹三、插值表示式示例1四、插值表示式示例2五、插值表示式注意點六、插值表示式補充總結一、vscode外掛介紹

正則表示式詳解01

正則表示式語法： 　　正則表示式描述了一種字串匹配的模式，可以用來檢查一個字串是否含有某種字串、將匹配的子串做替換或者從某個串中取出複核某個條件的子串等。

Java8 Lambda表示式詳解手冊及例項

Java8 Lambda表示式詳解手冊及例項 版權宣告：本文為博主原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處連結和本宣告。

crontab和cron表示式詳解

引言 我們在定時任務中經常能接觸到cron表示式，但是在寫cron表示式的時候我們會遇到各種各樣版本的cron表示式，比如我遇到過5位、6位甚至7位的cron表示式，導致我一度搞混這些表示式。更嚴重的是，當我們沒有準確寫