Lambda表達式---基本使用

什麼是lambda表達式？

1.一個匿名函數;

2.對接口的間接實現。

 

 1 /**
 2  * 1.lambda -- 一個匿名函數
 3  * 2.能夠對一個接口進行簡潔的實現
 4  * 3.要求接口中定義的抽象方法必須是一個
 5  */
 6 public class Demo1 {
 7     public static void main(String[] args) {
 8         //接口實現類
 9         Comparator comparator = new MyComparator();
10 
11         //匿名內部類
12         Comparator comparator2 = new Comparator() {
13             @Override
14             public int compare(int a, int b) {
15                 return a - b;
16             }
17         };
18 
19         //lambda
20         Comparator comparator3 = (a,b) -> a - b;
21     }
22 }
23 
24 class MyComparator implements Comparator{
25 
26     @Override
27     public int compare(int a, int b) {
28         return a - b;
29     }
30 }
31 
32 /**
33  * 抽象方法只有一個，修飾函數式接口
34  */
35 @FunctionalInterface
36 interface Comparator{
37     int compare(int a,int b);
38 }

 

幾種基本使用形式：

 

 

 1 public class BasicUse {
 2     public static void main(String[] args) {
 3         //() --- 參數列表
 4         //{} --- 方法體
 5         // -> --- lambda運算符 goes to
 6         NoReturnAndParam noReturnAndParam = () ->{
 7             System.out.println("Hello lambda");
 8         };
 9         noReturnAndParam.f();
10 
11         NoReturnSingleParam noReturnSingleParam = (int a) ->{
12             System.out.println(a);
13         };
14         noReturnSingleParam.f(100);
15         /**
16          * 單個參數可省略括號
17          * 且語句只有一條也可省略
18          */
19         NoReturnSingleParam noReturnSingleParam2 = a -> System.out.println(a);
20 
21         NoReturnMutiParam noReturnMutiParam = (int a,int b) ->{
22             System.out.println(a + b);
23         };
24         noReturnMutiParam.f(10,100);
25         /**
26          * 接口中定義了參數的類型,參數類型可省略，可是必須所有省略
27          * 精簡參數類型
28          */
29         NoReturnMutiParam noReturnMutiParam2 = (a,b) ->{
30             System.out.println(a + b);
31         };
32 
33         ReturnAndNoParam returnAndNoParam = () -> {
34             System.out.println("noParamWithReturn");
35             return 10;
36         };
37         int re = returnAndNoParam.f();
38         System.out.println(re);
39 
40         ReturnAndSingleParam returnAndSingleParam = (int a) ->{
41             return a * 100;
42         };
43         int reParam = returnAndSingleParam.f(20);
44         System.out.println(reParam);
45         /**
46          * 當語句只有一條return時，除了省略大括號還須要省略return
47          */
48         ReturnAndSingleParam returnAndSingleParam2 = a -> a * 10;
49 
50         ReturnAndMutiParam returnAndMutiParam = (int a,int b) ->{
51             return a - b;
52         };
53         int reParams = returnAndMutiParam.f(100,20);
54         System.out.println(reParams);
55 
56     }
57 }

 

方法引用

 1 public class MethodUse {
 2     public static void main(String[] args) {
 3         //方法引用
 4         /**
 5          * lambda表達式實現一個已經實現的函數
 6          * 方法所屬者
 7          * 類/對象
 8          * 方法參數類型和數量必定要和接口中對應
 9          * 返回值必須一致
10          */
11         ReturnAndSingleParam returnAndSingleParam = a -> change(a);
12 
13         ReturnAndSingleParam returnAndSingleParam2 = MethodUse::change;
14     }
15     private static int change(int a){
16         return a * 10;
17     }
18 }

構造器引用

 1 public class ConstructorUse {
 2     public static void main(String[] args) {
 3         PersonUse personUse = () -> new Person();
 4         //引用無參構造方法
 5         PersonUse personUse2 = Person::new;
 6         Person person = personUse2.getPerson();
 7         System.out.println(person);
 8 
 9         //引用有參構造方法
10         PersonUse2 personUse21 = Person::new;
11         Person person21 = personUse21.getPersonWithParam("Dave",26);
12         System.out.println(person21);
13     }
14 }
15 interface PersonUse{
16     Person getPerson();
17 }
18 
19 interface PersonUse2{
20     Person getPersonWithParam(String name,int age);
21 }

實例化線程

 1 public class ThreadUse {
 2     public static void main(String[] args) {
 3         /**
 4          * Runnable接口，無參無返回
 5          */
 6         Thread t1 = new Thread(() ->{
 7             for (int i = 0; i < 10 ; i++) {
 8                 System.out.println(i);
 9             }
10         });
11         t1.start();
12     }
13 }

閉包

 1 public class CloserDemo {
 2     public static void main(String[] args) {
 3         int n = getNumber().get();
 4         System.out.println(n);
 5     }
 6 
 7     /**
 8      * 閉包 --->獲取某個方法中的局部變量
 9      * 引用某個局部變量--- > 系統默認添加final常量
10      * @return
11      */
12     private static Supplier<Integer> getNumber(){
13         //提高局部變量的生命週期，在方法結束後仍能夠使用
14         int num =10;
15         return () -> {
16             return num;
17         };
18     }
19 }