前言：
这一系列的文章主要是为了学习SpringCloudGateWay，如官网所说，SpringCloudGateWay是基于 Spring Boot 2.x, Spring WebFlux, and Project Reactor的。并且Spring WebFlux中也用到了很多Project Reactor的知识，Reactor与Spring是兄弟项目，侧重于Server端的响应式编程，主要 artifact 是 reactor-core，这是一个基于 Java 8 的实现了响应式流规范 （Reactive Streams specification）的响应式库。所以在学习之前，我们首先需要对java8的lambda表达式以及流式编程有一定了解，这篇文章我们主要对lambda做一个总结学习
在学习lambda之前，我们先了解一个概念---------函数式编程
函数式编程：
参考链接：https://blog.csdn.net/u012611878/article/details/78495165
什么是函数式编程：
函数式编程（英语：functional programming）或称函数程序设计，又称泛函编程，是一种编程典范，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重要的基础是λ演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（引数）和输出（传出值）。
它属于”结构化编程”的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：
传统的过程式编程，可能这样写：
var a = 1 + 2; var b = a * 3; var c = b - 4;
函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：
var result = subtract(multiply(add(1,2), 3), 4);
这就是函数式编程。
函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。
比起命令式编程，函数式编程更加强调程序执行的结果而非执行的过程，倡导利用若干简单的执行单元让计算结果不断渐进，逐层推导复杂的运算，而不是设计一个复杂的执行过程。
函数式编程的特点
函数式编程近些年异军突起，又重新回到了人们的视线，并得到蓬勃发展。总结起来，无外乎如下好处：
1.减少了可变量(Immutable Variable)的声明，程序更为安全。
2.相比命令式编程，少了非常多的状态变量的声明与维护，天然适合高并发多现成并行计算等任务，这也是函数是编程近年又大热的重要原因。
3.代码更为简洁，可读性更强，对强迫症的同学来说是个重大福音。
lambda表达式：
核心：
对于lambda表达式我们首先明确一个概念，lambda其实就一个特定接口的实现实例。
我们通过一段代码来理解下这句话：
public class Demo01 { public static void main(String[] args) { // 可以看到在这一行，我们直接将一个lambda表达式赋值给了一个变量，这个lambda表达式其实就是一个实 // 现了Runnable接口的对象实例 Runnable lambdaRunnable = () -> System.out.println("lambda表达式执行了"); Runnable interfaceRunnable = new Runnable() { @Override public void run() { System.out.println("接口实现方法执行了"); } }; lambdaRunnable.run(); interfaceRunnable.run(); } }
现在我们再来看看jdk8中的一些跟lambda相关的内容
函数接口：
1.为什么需要使用函数接口？
我们看如下代码：
// 定义一个用于格式化字符串的接口 interface MyFormat { String format(String str); } public class Demo02 { public static void main(String[] args) { MyFormat format = new MyFormat() { @Override public String format(String str) { System.out.println("对字符串进行格式化，统一加后缀 ',hello'"); return str + ",hello"; } }; MyFormat lambdaFormat = str -> { System.out.println("采用lambda对字符串进行格式化，统一加后缀 ',hello，my name is lambda'"); return str + ",hello，my name is lambda"; }; String zhangsan = format.format("zhangsan"); System.out.println(zhangsan); } }
我们再采用jdk8中提供的函数接口来改造上面的代码：
public static void main(String[] args) { Function<String, String> function = str -> { System.out.println("采用lambda对字符串进行格式化，统一加后缀 ',hello，my name is function inteface'"); return str + ",hello，my name is function inteface"; }; function.apply("zhangsan"); }
对比以上几种写法，我们发现函数接口简化了的接口定义，原本我们需要专门定义一个format的顶层接口，而现在函数接口直接能实现这种简单接口的定义，我们在使用时只需要关注入参是什么，返回值是什么。只要明确这两点后，往往我们就能找到合适的函数接口
2.jdk8中提供了哪些函数接口？
消费型接口：
Conusmer<T> void accept(T t); BiConusmer<T,U> void accept(T t,U u); //增加一种入参类型
供给型接口：
Supplier<T> void get();
函数型接口：
Function<T ,R> R apply(T t); UnaryOperator<T> T apply(T t); //入参与返回值类型一致 BiFunction <T ,U,R> R apply(T t,U u); //增加一个参数类型 BinaryOperator<T> T apply(T t1,T t2); //两个相同类型入参与同类型返回值 ToIntFunction<T> //限定返回int ToLongFunction<T> //限定返回long ToDoubleFunction<T> //限定返回double IntFunction<R> //限定入参int,返回泛型R LongFunction<R> //限定入参long,返回泛型R DoubleFunction<R> //限定入参double,返回泛型R
断言型接口：
Predicate<T> boolean test(T t);
3.使用上面的这些函数式接口？
- 明确返回值，如果没有返回值，一定是消费型的函数接口。再确认入参个数，单个的话，为Conusmer，两个为BiConusmer
- 如果有返回值，看入参，不需要入参，为供给型接口Supplier
- 如果既有返回值又有入参，看入参个数，如果1个的话，为Function接口，两个的话为BiFunction
- 其余的一些接口，都是从上面几个接口衍生出来的
- 如果需要进行判断，需要使用Predicate接口进行断言
我们可以发现，上面的函数接口，参数个数最多为两个，但是当我们需要超过两个参数的情况该怎么办呢？这个时候我们需要自定义一些函数接口，如果定义一个函数接口呢？
假设我们现在需要定义一个三个参数的函数型接口，代码如下：
// 这个例子单纯为了说明这种情况，代码本身没有任何意义，大家不要纠结这个问题 @FunctionalInterface interface MyFunctionInterface { PersonAndDog apply(Dog dog, String str, Person person); } public class Demo03 { public static void main(String[] args) { MyFunctionInterface functionInterface = (dog, str, person) -> new PersonAndDog(); } } class Person { String name; } class Dog { String dogName; } class PersonAndDog { String someThing; }
我们可以看到，我们主要是添加了一个@FunctionalInterface的注解。其实不加这个注解，上面的代码也是完全可以的编译以及运行的。那么为什么我们需要添加这个注解呢？主要是为了在编译期对代码进行检查。因为申明为函数接口的接口只能有一个待实现的方法。我们想想看，当你申明了一个函数式接口，并且在项目的很多地方使用了它，结果有一天你的同事突然在这个接口中加了一个抽象方法。那么你之前所有的代码都原地爆炸了。这个注解的主要作用就是告诉别人，这是一个函数式接口，不能在其中添加其它抽象方法。当然，我们可以通过default关键字添加默认实现的方法，大家可以自行百度default关键字吗，这里不多赘述
方法引用：
主要分为以下两种情况：
- 静态方法引用
- 非静态方法引用
使用对象实例进行引
不使用对象实例进行引用
示例代码：
class Cat { int total = 10; static void miao(int num) { System.out.println("让猫叫" + num + "次"); for (int i = 0; i < num; i++) { System.out.println("喵"); } } int eat(int num) { System.out.println("猫吃了" + num + "斤猫粮"); total = total - num; System.out.println("还剩" + total + "斤猫粮"); return total; } } public class Demo04 { public static void main(String[] args) { // 静态方法引用 Consumer<Integer> consumer = Cat::miao; consumer.accept(2); // 非静态方法引用 // 1.通过对象实例引用 Cat cat = new Cat(); Function<Integer, Integer> eat = cat::eat; eat.apply(2); // 2.通过类名的方式调用 BiFunction<Cat, Integer, Integer> biFunction = Cat::eat; biFunction.apply(cat, 2); } }
**可以看到，对于非静态方法引用，必须要指明这个方法要作用于哪个对象。**当我们通过类名的方式的时候要在函数调用的时候传入这个对象，而当我们通过某一个对象调用的时候，只需要执行这个动作就可以了
类型推断：
这点我就不多说了，看如下代码：
interface Imath { int add(int x, int y); } public class Demo05 { public static void test(Imath imath) { System.out.println("test"); } public static void main(String[] args) { // 1.通过变量类型定义 Imath imath = (x, y) -> x + y; // 2.通过数组,集合 Imath[] imaths = {(x, y) -> x + y}; List<Imath> imaths1 = Collections.singletonList((x, y) -> x + y); // 3.强转 Object o = (Imath) (x, y) -> x + y; // 4.通过方法返回值限定 test((x, y) -> x + y); } }
总结下来，没有什么特别特俗的地方。只要lambda符合接口定义的规范，你可以把它用到任何接口能用到的地方，并且能自动推导出类型
变量引用：
我们直接通过代码说明问题
public class Demo06 { public static void main(String[] args) { String s = "haha"; int a = 10; Consumer<String> consumer = s1 -> { System.out.println(s1); }; } }
如果我们想在上述的代码中更改a的值是不允许的：
可以看到，编译报错，我们使用在lambda中的变量必须是final的或者是等同于final。什么叫等同于final呢？
我们更改上述代码：
public class Demo06 { public static void main(String[] args) { String s = "haha"; int a = 10; Consumer<String> consumer = s1 -> { System.out.println(s1); }; // 将赋值语句放到lambad之后，可以发现编译是通过的 a =20; } }
到这里我们可以总结了：
在lambda表达式中如果我们引用了外部的变量，不能改变这个变量。必须将其当作一个final类型的变量进行处理
级联表达式跟柯里化：
- 级联表达式
Function<Integer, Function<Integer, Integer>> function = x -> y -> x + y;
上面就是一个级联表达式。
- 柯里化
柯里化就是把多个参数的函数转换为只有一个参数的函数，其目的就是为了将函数标准化
我们对上面的函数进行调用：
Integer apply = function.apply(2).apply(3); System.out.println(apply);
这两个特性使用的不多，所以能看懂其含义就行，这里就不多介绍了。这篇文章就到这里，下篇文章我们开始进入流式编程的学习，希望在国庆期间能把这一系列的文章写文。
