lambda

Posted 2021-03-25 quyangyang

函数式编程只需要关注实现的功能，而不需要关注实现的细节

举例：

 1 public class DemoMain {
 2     
 3     /**
 4      * 求最小值
 5      * 
 6      */
 7     public static void main(String[] args) {
 8         int[] nums = {33,23,34,89};
 9         
10         int min = IntStream.of(nums).min().getAsInt();
11         System.out.println(min);
12         
13         
14     }
15 }

 

创建线程

 1 public class ThreadDemo {
 2     
 3     public static void main(String[] args) {
 4         new Thread(new Runnable() {
 5             
 6             @Override
 7             public void run() {
 8                     System.out.println("aaa");
 9             }
10         }).start();
11         
12         //jdk1.8
13         new Thread(()->System.out.println("aaa")).start();
14         
15     }
16 }

lamba表达式就是返回了一个实现指定接口的对象实例

 

jdk8 新增的接口默认方法

 1 /**
 2  * 接口要实现的方法必须只有一个(单一职责原则)
 3  */
 4 @FunctionalInterface
 5 interface inter {
 6     int doubleNum(int i);
 7     
 8     /**
 9      * 新增接口默认方法
10      */
11     default int add(int x,int y) {
12         return x+y;
13     }
14 }
15 
16 
17 @FunctionalInterface
18 interface inter2 {
19     int doubleNum(int i);
20     
21     /**
22      * 新增接口默认方法
23      */
24     default int add(int x,int y) {
25         return x+y;
26     }
27 }
28 
29 
30 @FunctionalInterface
31 interface inter3 extends inter,inter2 {
32 /**
33  * 指明重复的默认方法
34  */
35     @Override
36     default int add(int x, int y) {
37         // TODO Auto-generated method stub
38         return inter2.super.add(x, y);
39     }
40 
41 }
42 
43 
44 
45  
46 public class LambdaDemo {
47     
48 
49     public static void main(String[] args) {
50         
51         inter i1 = (i) -> i*2;  //1
52         
53         System.out.println(i1.doubleNum(20));
54         
55         System.out.println(i1.add(10,20));
56         
57         inter i2 = i->i*2;  //2
58         
59         inter i3 = (int i)->i*2;  //3
60         
61         inter i4 = (int i)->{
62             System.out.println("aaa");
63             return i*2;
64         };   //4    
67     }
68 
69 }

 

函数接口

 1 /**
 2  * 函数接口好处
 3  * 1.不用定义多的接口
 4  * 2.支持链式的操作
 5  * @author 11658
 6  */
 7 
 8 
 9 /**
10  *定义输入类型int，输出类型String
11  */
12 //interface IMoneyFormot{
13 //    String format(int i);
14 //}
15 
16 
17 class MyMoney{
18     private final int money;
19     
20     public MyMoney(int money) {
21         this.money = money;
22     }
23     
24     public void printMoney(Function<Integer,String> iMoneyFormot) {
25 //        System.out.println("我的存款:"+ iMoneyFormot.format(this.money));
26         System.out.println("我的存款："+ iMoneyFormot.apply(this.money));
27         
28     }
29     
30 }
31 
32 public class InterDemo {
33     
34     public static void main(String[] args) {
35         
36         
37         MyMoney me = new MyMoney(1000);
38         
39         Function<Integer, String> iMoneyFormot = i -> new DecimalFormat().format(i);
40         //链式操作
41         me.printMoney(iMoneyFormot.andThen(s->"$"+s));
42         
43         
44     }
45 
46 }

举例：

 1 public class FunctionDemo {
 2     
 3     public static void main(String[] args) {
 4         //断言函数
 5         //IntPredicate predicate = i -> i >0;
 6         Predicate<Integer> predicate = i -> i >0;
 7         System.out.println(predicate.test(-9));
 8         
 9 
10         //消费函数接口
11         Consumer<String> consumer = s -> System.out.println(s);
12         consumer.accept("aaaa");
13                     
14     }        
15 }

 

方法引用

 

1.静态方法引用

2.使用对象实例方法引用

3.使用类名来引用

4.构造函数方法引用

 1 class Dog{
 2     private String name = "金毛";
 3     
 4     private int food = 10;
 5     
 6     public static void bark(Dog dog) {
 7         System.out.println(dog+"在叫");
 8     }
 9     
10     /**
11      *吃狗粮
12      *输入 int 输出 int
13      */
14     public int eat(int num) {
15         System.out.println("吃了"+num+"斤");
16         this.food -= num;
17         return this.food;
18     }
19     
20     
21     @Override
22     public String toString() {
23         return this.name;
24     }
25 }
26 
27 
28 
29 public class MethodDemo {
30     
31     public static void main(String[] args) {
32         /**
33          * lambda表达式实际是匿名函数
34          * 函数左边是函数参数，右边是函数执行体
35          * 当函数执行体只有一个函数调用时，函数的参数和箭头左边一样，就可以缩写成方法引用的方式
36          */
37 
38         //Consumer<String> consumer = s->System.out.println(s);
39         
40         Consumer<String> consumer = System.out::print;
41         
42         consumer.accept("aaa");
43         
44         
45         
46         //1.静态方法的方法引用
47         //类名::静态方法名
48         Consumer<Dog> consumer2 = Dog::bark;
49         Dog dog = new Dog();
50         
51         consumer2.accept(dog);
52         
53         //非静态方法引用
54         //2.使用对象实例方法引用
55         //实例：：方法名
56         Function<Integer,Integer> function = dog::eat;
57         //方法的输入和输出类型一样，可改为一元函数接口
58     //    UnaryOperator<Integer> function = dog::eat;
59         
60         System.out.println("还剩"+function.apply(2)+"斤");
61         
62     }
63 }

aaa金毛在叫
吃了2斤
还剩8斤

 1 class Cat{
 2     private String name = "小猫";
 3     
 4     private int food = 10;
 5     
 6     /**
 7      * 创建构造函数
 8      */
 9     public Cat() {
10         
11     }
12     
13     //分析：输入String,输出当前类的实例
14     public Cat(String name) {
15         this.name = name;
16     }
17 
18 /**
19  * eat 方法,
20  * jdk 默认会把当前实例传入到非静态方法，参数名是this,位置是第一个
21  * 用类名对非静态方法做引用的时候，实际上是有两个输入，一个输出
22  * 
23  */
24     public int eat(Cat this,int num) {
25         System.out.println("吃了"+num+"斤");
26         this.food -= num;
27         return this.food;
28     }
29     
30     
31     @Override
32     public String toString() {
33         return this.name;
34     }
35 }
36 
37 
38 
39 public class MethodDemo2 {
40     
41     public static void main(String[] args) {
42         
43         Cat cat = new Cat();
44         cat.eat(2);
45         
46 
47         Function<Integer,Integer> function = cat::eat;
48 
49         System.out.println("还剩"+function.apply(2)+"斤");
50         
51         //Cat::eat
52         //3.使用类名来引用方法
53         BiFunction<Cat,Integer,Integer> eatFunction = Cat::eat;
54         System.out.println("还剩"+eatFunction.apply(cat, 2)+"斤");
55         
56         
57         //4.构造方法的引用  ，没有参数时，没有输入只有输出
58         //类名：：new
59         Supplier<Cat> supplier = Cat::new;
60         System.out.println(supplier.get());
61         
62         
63         
64     /** 带参数的构造函数方法的引用
65      *  分析：输入String,输出当前类的实例
66      *     public Cat(String name) {
67      *       this.name = name;
68         }
69      */
70     Function<String,Cat> function2 = Cat::new;    
71     System.out.println(function2.apply("大橘"));    
72         
73     }
74     
75 }

吃了2斤
还剩4斤
小猫
大橘

 

类型推断

 1 /**
 2  * 类型推断
 3  * lambda表达式实际上是匿名函数，返回了一个指定接口的对象，究竟实现那个接口，否则就报错
 4  * 这就是类型推断
 5  */
 6 
 7 @FunctionalInterface
 8 interface IMath{
 9     int add(int x,int y);
10 }
11 
12 
13 
14 
15 public class TypeDemo {
16     
17     public static void main(String[] args) {
18         
19         //变量类型定义
20         IMath math = (x,y) ->x+y;
21         
22         //数组里
23         IMath[] math2 = {(x,y) -> x+y};
24         
25         //强转
26         Object math3 = (IMath)(x,y) -> x+y;      
27         
28         //通过返回类型
29         IMath createLambda = createLambda();
30         
31         TypeDemo demo = new TypeDemo();
32         //指定方法
33         //当有二义性时，使用强转对应的接口解决
34         demo.test((x,y) -> x+y);
35         
36     }
37     
38     //通过方法指定接口，进行匹配
39     public void test(IMath math) {}
40     
41     
42     private static IMath createLambda() {
43         
44         return (x,y) ->x+y;
45         
46     }
47     
48 }

 

变量引用

 1 /**
 2  * 变量引用
 3  * @author 11658
 4  *
 5  */
 6 public class VarDemo {
 7     
 8     public static void main(String[] args) {
 9         /**
10          * 匿名类引用外部变量必须为final ? 保证里面的变量和外部的变量指向同一个对象
11          * 传参的形式是传值而不是传引用，
12          */
13         final String str = "aaa";
14         Consumer<String> consumer = s -> System.out.println(s+str);
15 
16         consumer.accept("1222");
17     }
18 
19 }

1222aaa

 

级联表达式和柯里化

 1 /**
 2  * 级联表达式和柯里化
 3  * 柯里化：把多个参数的函数转换为只有一个参数的函数
 4  * 目的：函数标准化
 5  */
 6 public class CurryDemo {
 7 
 8     
 9     
10     public static void main(String[] args) {
11         
12         Function<Integer, Function<Integer,Integer>> fun= x -> y-> x+y;
13         
14         System.out.println(fun.apply(2).apply(3));
15         
16         
17         //函数标准化，进行统一处理
18         Function<Integer, Function<Integer,Function<Integer,Integer>>> fun2= x->y->z->x+y+z;
19         
20         System.out.println(fun2.apply(2).apply(3).apply(4));
21         
22         
23     }
24     
25     
26     
27 }

 

 

 

 

完