Lambda表达式---基本使用

 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 }