0202年了，还没有用上Java函数式编程！！！——Lambda表达式javau011664145的博客-

函数式编程是什么

这里不得不提的一个点，叫做编程范式，即一类典型的编程风格，那么有哪些比较通用的范式呢

命令式编程(Imperative)

这个其实很好理解，计算机硬件运行指令的方式，就是命令式的，而高级语言中，常用的循环语句，条件语句，就属于这类，即告诉计算机硬件一步一步要去怎样做。

声明式编程(Declarative)

声明式编程是以数据结构的形式来表达程序执行的逻辑，即告诉计算机应该要做什么，常见的形式：SQL（结构化查询语言）

函数式编程(Functional)

函数式编程跟声明式有同样的指导思想，即关注要做什么，但函数式提现函数为第一公民的原则，值得注意的事这里的函数术语指的是一种映射关系，也就是数学中的函数而非计算机中的函数。这里我们可以用一种更简单的方式去对比理解，面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象。

总结

函数式编程关心数据的映射，命令式编程关心解决问题的步骤。

函数式编程的好处

• 代码简洁，开发快速
• 接近自然语言，易于理解

举例说明之: 有三个”字符串”都说自己比较长，那么到底谁最长？

Stream.of("我长","我才长","你两都没有我长").mapToInt(String::length).summaryStatistics().getMax() 

我们来拆分一下（注意方法名的含义）

1. Stream.of(“我长”,“我才长”,“你两都没有我长”)：构建了这三个字符组成的流。
2. mapToInt(String::length)： 转化每个字符的长度（int类型）。
3. summaryStatistics()： 统计前面的长度数据。
4. getMax()： 获取最大的长度。

简单的一行代码就完成了这个需求，同时轻松易读，何乐而不为之！！！

Lambda表达式

首先我们得明白一点，函数式编程，是可以借助lambda表达式去实现的，所以理解lambda表达式就是一个重点了，而lambda表达式的规则是函数式接口了。

函数式接口

函数式接口：只包含了一个抽象方法的接口。
举个栗子，我们的“精神领袖”——“”窃.格瓦拉“”，就是不打工(对不起！！！)

/**  * <Description> “精神领袖”——“窃.格瓦拉”,用于展示函数式接口，不打工是我们唯一的抽象方法 <br>  * @author 妖帝艾雷诺 <br>  * @version 1.0 <br>  * @createDate 2020/04/20 16:42 <br>  */ @FunctionalInterface public interface CheGuevara { /**      * 不打工      */ void notWork(); } 

@FunctionalInterface 注解仅用于标识该接口为函数接口，让编译器能够检查是否符合一个抽象方法。

五种形式

定义了函数式接口后，就要使用了，语法格式如：

(parameters) -> expression 或 (parameters) -> { expression }

1.无参数

实现：

    CheGuevara cheGuevara = ()-> System.out.println("这辈子都不可能打工的！！！"); 

简单理解的话，就是一种语法糖，对比平时我们用的匿名内部类：

    CheGuevara cheGuevara = new CheGuevara() { @Override public void notWork() {                 System.out.println("这辈子都不可能打工的！！！"); } }; 

2.有单个参数

接口：

 /**      * 不打工 (单参数)      * @param electromobile 电瓶车      */ void notWork(String electromobile); 

实现：

    CheGuevara cheGuevara = (electromobile)-> System.out.println("这辈子都不可能打工的！！！ 我只想拿【"+electromobile+"】"); 

3.有多个参数

接口：

 /**      * 不打工（多参数）      * @param electromobile 电瓶车      * @param bicycle 自行车      */ void notWork(String electromobile, String bicycle); 

实现：

    CheGuevara cheGuevara = (electromobile, bicycle)-> System.out.println("这辈子都不可能打工的！！！ 我想拿【"+electromobile+"】和拿【"+bicycle+"】"); 

4.实现有多行

接口：

 /**      * 不打工（多参数）      * @param electromobile 电瓶车      * @param bicycle 自行车      */ void notWork(String electromobile, String bicycle); 

实现：

    CheGuevara cheGuevara = (electromobile, bicycle)-> {             System.out.println("这辈子都不可能打工的！！！");             System.out.println("我想拿【"+electromobile+"】");             System.out.println("还要拿【"+bicycle+"】"); }; 

5.带类型

通过前面的例子，应该不难发现，参数是没有带有类型的，因为编译器可以通过原先定义的方法判断参数类型，也就是类型推断，有的时候，你想知道具体类型的话，也可以加上，如：

    CheGuevara cheGuevara = (String electromobile, String bicycle)-> {             System.out.println("这辈子都不可能打工的！！！");             System.out.println("我想拿【"+electromobile+"】");             System.out.println("还要拿【"+bicycle+"】"); }; 

方法引用

Java8为了使lambda表达式更加精简，提供了方法引用，前提是，lambda表达式只有一行，其语法格式：

首先方法引用是惰性的，包括前面定义的各种形式，都是惰性的，因为它们仅仅是定义了，并没有真正开始执行，那么怎样才算调用执行，拿上个例子说明：

    cheGuevara.notWork("某某牌电动车", "某某牌自行车"); 

接着，让我们看看方法引用怎么用，还是用多参数的例子，
接口：

 /**      * 不打工（多参数）      * @param electromobile 电瓶车      * @param bicycle 自行车      */ void notWork(String electromobile, String bicycle); /**      * 不打工（Java8接口静态方法，用于展示“方法引用”, 不一定非要在这个接口写实现方法，也可以用其他类）      * @param electromobile 电瓶车      */ static void staticNotWork(String electromobile, String bicycle){         System.out.println("这辈子都不可能打工的！！！我想拿【"+electromobile+"】和拿【"+bicycle+"】"); } 

实现：

    CheGuevara cheGuevara = CheGuevara::staticNotWork; 

调用仍然是：

    cheGuevara.notWork("某某牌电动车", "某某牌自行车"); 

留下个问题，大家思考下，我上述例子对应的是方法引用的那种类型呢？
当然，像伟大的IntelliJ IDEA有智能的提示，如果发现你的lambda表达式里能够转化为更精简的方法引用的话。

常用内置函数式接口

我们上述例子，都是围绕自定义的“窃.格瓦拉”函数式接口，难道我们用lambda表达式，就非要自己定义么，当然不是，Java8内置了很多函数式接口，这里举主要的几个(其他的是这几种接口的变式，大同小异，详细可参考菜鸟教程的函数式接口)，进行说明。（注意：每个函数式接口仅列举了一个方法，其他的方法使用，建议看源码或者Java8 API）

定义一个具体的“窃.格瓦拉”来说明，跟上面其他例子关联不大，仅仅为了延续上面的风格，方便理解。

 /**  * <Description> 一位看似忠诚的“窃.格瓦拉”的信仰者 <br>  *  * @author 妖帝艾雷诺 <br>  * @version 1.0 <br>  * @createDate 2020/04/20 23:12 <br>  */ public class CheGuevaraImpl implements CheGuevara{ @Override public void notWork(String electromobile, String bicycle) {         System.out.println("这辈子都不可能打工的,哪怕你连一百块都不给我！！！但我不拿【"+electromobile+"】也不拿【"+bicycle+"】"); } } 

Supplier< T >

 //利用Supplier定义一个的"窃.格瓦拉",用方法引用简化new操作         Supplier<CheGuevaraImpl> cheGuevaraSupplier = CheGuevaraImpl::new; 

Consumer< T >

消费：

 //定义一个消费行为，怎么消费的（惰性，还未执行）         Consumer<CheGuevaraImpl> cheGuevaraImplConsumer = cheGuevaraImpl1 -> {             System.out.println("花了一百块钱，买醉。没钱了！！！"); }; //接收Supplier提供的一个具体的"窃.格瓦拉"，然后作为消费者，进行真实消费 （真正执行）         cheGuevaraImplConsumer.accept(cheGuevaraSupplier.get()); 

消费结果

花了一百块钱，买醉。没钱了！！！ 

Function< T ，R >

结合上面Consumer<T>的例子，如下：

        Function<CheGuevaraImpl, String> cheGuevaraStringFunction = cheGuevaraImpl2->{ //输入消费(利用上面定义的消费行为，对当前输入的"窃.格瓦拉"进行接收)             cheGuevaraImplConsumer.accept(cheGuevaraImpl2); //输出 return "吐了"; }; //接收Supplier提供的一个具体的"窃.格瓦拉"，然后作为消费者，进行真实消费,并输出         String output = cheGuevaraStringFunction.apply(cheGuevaraSupplier.get());         System.out.println(output); 

结果：

花了一百块钱，买醉。没钱了！！！ 吐了 

Predicate< T >

Predicat常用于判断的场景，比如说，判断当前输入数字是否大于100。（对不起，”窃.格瓦拉”的例子，在这实在编不出来了）

  Predicate<Integer> integerPredicate = x-> x > 100;         System.out.println("50 > 100 = "+integerPredicate.test(50)); 

结果：

50 > 100 = false 

总结

1. 编程范式：函数式编程是一种编程范式，常见的还有命令式编程，声明式编程，常见的面向对象编程是一种命令式编程。
2. 面向对象编程是对数据进行抽象，而函数式编程是对行为进行抽象，现实世界中，数据和行为并存，程序也是如此，因此这两种编程方式我们都得学。
3. 函数式编程的核心思想：在思考问题时，使用不可变值和函数，函数对一个值进行处理，映射成另一个值（ 函数式编程的一个特点就是可以把函数作为参数传递给另一个函数，也就是所谓的高阶函数）

最后

初次写博客，水平有限，有问题，还望不吝赐教！！！欢迎大家留言讨论，同时欢迎转载，但请注明出处和作者。
所有示例，上传至 https://github.com/zhiwen-li/Exemplar-learning

参考

• [1] [英] Richard Warburton著,王群锋译.Java8 函数式编程[M].人民邮电出版社:北京,2015.4.
• [2] 李刚.疯狂Java讲义（第4版）[M].电子工业出版社:北京,2018.1.
• [3] backslash112.编程范式：命令式编程(Imperative)、声明式编程(Declarative)和函数式编程(Functional)[EB/OL].https://www.cnblogs.com/sirkevin/p/8283110.html,2018-01-15.