多线程09：Lambda表达式

Lambda表达式
1.概述
  • λ希腊字母表中排序第十一位的字母，英文名称为Lmbda
  • 它的出现是为了简化，以前的代码很繁琐简化成
new Thread(()-> System.out.println("多线程学习。。。")).start();
  • 其实质属于函数式编程的概念。
 
2.为什么要使用lambda表达式？
  • 避免匿名内部类定义过多
  • 可以让你的代码看起来很简洁
  • 去掉了一堆没有意义的代码，只留下核心的逻辑
 
3.了解lambda表达式之前，需要了解一下函数式接口
  • 理解Functional Interface(函数式接口)是学习lambda表达式的关键所在
  • 函数式接口的定义：
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
public interface Runnable {
public abstract void run();
}
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
 
用代码推导一下：
1、外部类：
 1 package com.thread.lambda;
 2 public class TestLambda1 {
 3     public static void main(String[] args) {
 4         like = new Like2();
 5         like.lambda();
 6     }
 7 }
 8 
 9 //1.定义一个函数式接口
10 interface ILike {
11     void lambda();
12 }
13 //2.实现类
14 class Like2 implements ILike {
15     @Override
16     public void lambda() {
17         System.out.println("i like lambda");
18         }
19     }
20     
21 结果：
22 i like lambda
2、 把实现类放在内部：静态内部类
 1 package com.thread.lambda;
 2 public class TestLambda1 {
 3 
 4     //2.静态内部类
 5     static class Like2 implements ILike {
 6         @Override
 7         public void lambda() {
 8             System.out.println("i like lambda2");
 9         }
10 
11     }
12 
13     public static void main(String[] args) {
14         like = new Like2();
15         like.lambda();
16     }
17 }
18 
19 //1.定义一个函数式接口
20 interface ILike {
21     void lambda();
22 }
23 
24 结果：
25 i like lambda2
3、把实现类放在方法里面：局部内部类
 1 package com.thread.lambda;
 2 
 3 /*
 4 推导lambda表达式
 5  */
 6 public class TestLambda1 {
 7     public static void main(String[] args) {
 8         //2.局部内部类
 9         class Like3 implements ILike {
10             @Override
11             public void lambda() {
12                 System.out.println("i like lambda3");
13             }
14 
15         }
16         ILike like = new Like3();
17         like.lambda();
18 
19 
20     }
21 }
22 
23 //1.定义一个函数式接口
24 interface ILike {
25     void lambda();
26 }
27 
28 结果：
29 i like lambda3
4、匿名内部类，没有类的名称，必须借助接口或者父类
 1 package com.thread.lambda;
 2 
 3 /*
 4 推导lambda表达式
 5  */
 6 public class TestLambda1 {
 7     public static void main(String[] args) {
 8     //2.匿名内部类
 9     like = new ILike() {
10         @Override
11         public void lambda() {
12             System.out.println("i like lambda4");
13             }
14         };
15         like.lambda();
16     }
17 }
18 
19 //1.定义一个函数式接口
20 interface ILike {
21     void lambda();
22 }
23 
24 结果：
25 i like lambda4
5、JDK1.8出来的lambda表达式简化
 1 package com.thread.lambda;
 2 
 3 /*
 4 推导lambda表达式
 5  */
 6 public class TestLambda1 {
 7     public static void main(String[] args) {
 8        //2.用lambda表达式简化
 9          like = ()->{
10         System.out.println("i like lambda5");
11         };
12         like.lambda();
13     }
14 }
15 
16 //1.定义一个函数式接口
17 interface ILike {
18     void lambda();
19 }
20 
21 结果：
22 i like lambda5
5、放一起
思路：
  1. 首先要有一个函数式接口，就是那个接口只有一个抽象方法
  2. 外部用一个类去实现接口，实现它的方法，在里面进行了了一个new创建对象调用对象的方法。
  3. 然后外面比较麻烦，于是乎，流了一个Like2，静态内部类去实现
  4. 然后，静态内部类还麻烦，就把Like3类放在方法里面，写了一个局部内部类。
  5. 局部内部类还是麻烦，用了一个匿名内部类，匿名内部类就是没有类的名称，必须借助接口或者父类，接口父类的话，要重写它的方法。
  6. 接口只有一个类，且只有一个方法，符合函数表达式，则用lambda表达式简化匿名内部类。

package com.thread.lambda;

/*
推导lambda表达式
 */
public class TestLambda1 {

    //3.静态内部类
    static class Like2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }

    }

    public static void main(String[] args) {
        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 {
    void lambda();
}

//2.实现类
class Like implements ILike {

    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }

}

结果：
i like lambda
i like lambda2
i like lambda3
i like lambda4
i like lambda5
再举个例子，带参数的：
 1 package com.thread.lambda;
 2 
 3 public class TestLambda2 {
 4 
 5     //2.静态内部类
 6     static class Love2 implements ILove {
 7 
 8         @Override
 9         public void love(int a) {
10             System.out.println("i love you-->" + a);
11         }
12     }
13 
14     public static void main(String[] args) {
15         ILove love = new Love();
16         love.love(1);
17 
18         love = new Love2();
19         love.love(2);
20 
21         //3.局部内部类
22         class Love3 implements ILove {
23 
24             @Override
25             public void love(int a) {
26                 System.out.println("i love you-->" + a);
27             }
28         }
29         love = new Love3();
30         love.love(3);
31 
32         //4.匿名内部类
33         love = new ILove() {
34             @Override
35             public void love(int a) {
36                 System.out.println("i love you-->" + a);
37             }
38         };
39         love.love(4);
40 
41         //5.lambda表达式简化
42         love = (int a) -> {
43             System.out.println("i love you-->" + a);
44         };
45         
46         //简化1.去掉参数类型
47         love = (a) -> {
48             System.out.println("i love you-->" + a);
49         };
50         
51         //简化2.简化括号
52         love = a -> {
53             System.out.println("i love you-->" + a);
54         };
55         
56         //简化3：去掉花括号
57         love = a -> System.out.println("i love you-->" + a);
58         //总结：
59             //lambda表达式在只有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹
60             //前提是接口是函数式接口
61             //多个参数也可以去掉参数类型，要去掉都去掉,但必须加上括号
62         love.love(520);
63     }
64 }
65 
66 //定义一个函数式接口，只有一个抽象方法
67 interface ILove {
68     void love(int a);
69 }
70 
71 //1.外部实现类
72 class Love implements ILove {
73 
74     @Override
75     public void love(int a) {
76         System.out.println("i love you-->" + a);
77     }
78 }
79 
80 结果：
81 i love you-->1
82 i love you-->2
83 i love you-->3
84 i love you-->4
85 i love you-->520

 

posted @ 2020-02-04 18:41  断浮  阅读(825)  评论(0)  编辑  收藏  举报