Java多线程-lambda表达式

什么是lambda 表达式

它是Java8函数式接口(function interface),Lambda 表达式（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）

为什么要用lambda表达式

1 避免匿名内部类定义过多

2 key让代码看起来更加整洁

3 去掉一推没有意义的代码,只留下核心的逻辑

lambda 表达式可以简化我们的代码本质属于函数式编程

函数式接口的定义

1 任何接口,如果只包含唯一一个抽象方法，那么它就是函数式接口

runnable接口就是一个lambda表达式

//比如Runnable接口中的run方法   一个接口只有唯一一个抽象方法,就是函数式接口,就可以用lamda表达式创建该接口的对象
public interface Runnable{
    public abstract void run();
}
1
2
3
4

2 对于函数式接口,我们可以使用lambda表达式来创建该接口的对象

package com.wyh.lamda;

/**
 * @program: Thread
 * @description: lambda表达式测试
 * @author: 魏一鹤
 * @createDate: 2021-12-30 22:39
 **/

//3 静态内部类

//推导lambda表达式
public class TestLambda1 {
  static  class Like2 implements ILike {

        @Override
        public void lambda() {
            System.out.println("I Like Lambda2");
        }
    }

    public static void main(String[] args){
            //用接口去创建对象  接口去new它的实现类
            ILike like=new Like();
            like.lambda();

            like= new Like2();
            like.lambda();

            //4 局部内部类
        class Like3 implements ILike {

            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        }
        like=new Like3();
        like.lambda();

        //5 匿名内部类,没有类的名称,必须借助接口或者父类
        like=new ILike() {
            @Override
            public void lambda() {
                System.out.println("I Like Lambda4");
            }
        };
        like.lambda();
        //6 用lambda简化
       like=()-> {
            System.out.println("I Like Lambda5");
        };
       like.lambda();
    }
}
//1 定义一个函数式接口
interface ILike{
    abstract  void lambda();
}
//2 实现类  去实现接口
class Like implements ILike {
    @Override
    public void lambda() {
        System.out.println("I Like Lambda");
    }
} 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

例子

下面是一个带参数的lambda表达式的例子

package com.wyh.lamda;

/**
 * @program: Thread
 * @description: Lambda表达式
 * @author: 魏一鹤
 * @createDate: 2021-12-30 23:00
 **/

public class TestLambda2 {
    //静态内部类

    public static void main(String[] args){

        //1 lambda表达式简化
        ILove love =(int num)-> {
            System.out.println("I Love You -->"+num);
        };

        //简化1 去掉参数类型
        love=(num)-> {
            System.out.println("I Love You -->"+num);
        };
        // 简化2  去掉括号
        love=num-> {
            System.out.println("I Love You -->"+num);
        };
        //简化3 去掉花括号
        love=num->System.out.println("I Love You -->"+num);

        //总结
        //lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码块({}花括号)包裹
        //前提是函数式接口 接口只有一个方法
        //多个参数也可以去掉数据类型,要去掉都去掉,要留下都留下,必须加括号把参数括起来(a,b)
        love.ILove(520);



    }
}
//定义一个函数式接口 带参数
interface  ILove{
    void ILove(int num);
}
//定义类实现接口
class Love implements ILove {

    @Override
    public void ILove(int num) {
        System.out.println("I Love You -->"+num);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

简化方式

简化1 去掉参数类型

love=(num)-> {
    System.out.println("I Love You -->"+num);
};
1
2
3
4

简化2 去掉括号

love=num-> {
    System.out.println("I Love You -->"+num);
};
1
2
3

简化3 去掉花括号

love=num->System.out.println("I Love You -->"+num);
1

代码总结

1 lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码块({}花括号)包裹

2 前提是函数式接口 接口只有一个方法

3 多个参数也可以去掉数据类型,要去掉都去掉,要留下都留下,必须加括号把参数括起来(a,b)

最终简化代码

package com.wyh.lamda;

/**
 * @program: Thread
 * @description: Lambda表达式
 * @author: 魏一鹤
 * @createDate: 2021-12-30 23:00
 **/

public class TestLambda2 {
    //静态内部类

    public static void main(String[] args){

        ILove love;
        // 简化2  去掉括号
        love=(num,num2,num3)-> {
            System.out.println("I Love You -->"+num);
        };


        //总结
        //lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码块({}花括号)包裹
        //前提是函数式接口 接口只有一个方法
        //多个参数也可以去掉数据类型,要去掉都去掉,要留下都留下,必须加括号把参数括起来(a,b)
        love.ILove(520,123,232);



    }
}
//定义一个函数式接口 带参数
interface  ILove{
    void ILove(int num,int num2,int num3);
}
//定义类实现接口
class Love implements ILove {

    @Override
    public void ILove(int num1,int num2,int num3) {
        System.out.println("I Love You -->"+num1);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46