Lambda 表达式（Lambda Expression），相信大家对 Lambda 肯定是很熟悉的，毕竟我们数学上经常用到它，即 λ 。不过，感觉数学中的 Lambda 和编程语言中的 Lambda 表达式没啥关系，要说有关系就是都有 Lambda 这个词，噢！当然还有一个关系就是 Lambda 演算。
λ 演算（英语：lambda calculus，λ-calculus）是一套从数学逻辑中发展，以变量绑定和替换的规则，来研究函数如何抽象化定义、函数如何被应用以及递归的形式系统。它由数学家阿隆佐·邱奇在20世纪30年代首次发表。lambda演算作为一种广泛用途的计算模型，可以清晰地定义什么是一个可计算函数，而任何可计算函数都能以这种形式表达和求值，它能模拟单一磁带图灵机的计算过程。
回到编程语言这方面，其实不只是 java 引入了这个 Lambda 表达式，其他编程语言也有，比如 C 、Javascript、Python 等等。当然，本篇文章回顾的是 Java 中的 Lambda 表达式。
作为一个初学者，下面对于 Lambda 的理解肯定不够严谨，甚至可能包含错误，望观众老爷们能在评论区指出！
为什么要学这个 Lambda 表达式？- Java 8 的新特性，简化代码的编写。
- 工作中会用到，防止看不懂别人写的代码。
- 大家都学我也学。
Lambda 表达式是一个匿名函数，换句话说，你有匿名函数，那么它这个函数就是所谓的 Lambda 表达式。
所谓匿名函数，顾名思义，就是没有函数名的函数。
那么肯定有小伙伴会说，没有函数名，那我怎么调用这个函数啊？
是的，这个问题问得很好，先保持这个疑问！在回答这个问题之前，我先来说说另一个概念——「函数式编程」。
什么是函数式编程？函数式编程是一种编程范式，除此之外，还有声明式编程、命令式编程，也都是编程范式。
好吧，这里又扯出一个新的专业名词——「编程范式（Programming Paradigm）」。范式？相信正在阅读的你，在学习数据库知识的时候，肯定学过第一范式、第二范式、第三范式，那现在又有一个编程范式，这是什么鬼？
百度百科是这样说的：
编程范型、编程范式或程序设计法（英语：Programming paradigm），（范即模范、典范之意，范式即模式、方法），是一类典型的编程风格，是指从事软件工程的一类典型的风格（可以对照方法学）。如：函数式编程、程序编程、面向对象编程、指令式编程等等为不同的编程范型。
是不是太官方了，没关系，简单理解，我认为知道函数式编程是一种写代码时的风格就OK了。
我们需要注意的是，函数式编程中的「函数」二字，是数学上的函数，并不是我们现在习惯理解的函数，也就是说，这是纯纯数学概念上的函数，即自变量的映射，比如 y = f(x)y=f(x)，自变量 xx，通过函数 ff 映射成 yy 。
函数式编程和 Lambda 表达式有什么关系？可以说，函数式编程允许使用一种表达式来表示一个函数，这种表达式就是 Lambda 表达式。
在 Java 中，函数式编程是通过一个接口规范来实现的，接口具有这种特点：
- 该接口有且只有一个抽象方法
- 该接口使用 @FunctionalInterface 注解进行标识
具有这个特点的接口称为「函数式接口」。
现在，回到最开始说的，「没有函数名，那我怎么调用这个函数啊？」，这就是函数式接口的用途了，接口中只有一个抽象方法，不用指定方法名称，就能够用 Lambda 表达式来调用这个函数（方法）了，不需要知道函数名就能够实现调用。好比想在某个房间（接口）找个人（方法）来做事，我这个房间只有一个人，那么除了这个人，没有其他人可以来做事了，就不需要指定那谁谁谁过来帮忙，而是直接喊：就决定是你了！（这个比喻可能也不是很恰当，当大概意思是这样哈哈哈）
函数式接口Comparator我们可以看看 Comparator 接口，它有 @FunctionalInterface 注解，那么可以肯定它是一个函数式接口。
@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
default Comparator<T> reversed() {
return Collections.reverseOrder(this);
}
default Comparator<T> thenComparing(Comparator<? super T> other) {
Objects.requireNonNull(other);
return (Comparator<T> & Serializable) (c1, c2) -> {
int res = compare(c1, c2);
return (res != 0) ? res : other.compare(c1, c2);
};
}
...
}
复制代码
有小伙伴应该要说了，这个接口这么多方法，为什么还能是函数式接口？
注意了啊，我们可以看到一个好像是抽象的 equals 方法，但是，因为 equals 是 Object 中的方法，这种对Object 类的方法的重新声明是会让方法变成一个具体的方法。所以，不要误会了，这里的抽象方法就只有 compare 方法。
那可能有小伙伴要说了，接口中还能有具体的方法？
是的，没错，在 Java 8 中，接口中可以写具体的方法了。比如上面的 reversed 和 thenComparing 方法，都是具体的方法。
常见的函数式接口- java.lang.Runnable
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
复制代码
- java.util.concurrent.Callable
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
复制代码
- java.lang.reflect.InvocationHandler
@FunctionalInterface
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
复制代码如何使用 Lambda 表达式？
在 Java 8 之前，我们使用 Collections 的需要比较器的 sort 方法，是这样的。
等等，忘了有比较器参数的 sort 方法了？没关系，代码给你贴上：
public static <T> void sort(List<T> list, Comparator<? super T> c) {
list.sort(c);
}
复制代码
最开始的写法是这样的，由于 Comparator 是一个接口，不能直接实例化，所以需要一个类来实现这个接口作为真正的比较器类，然后将这个 Comparator 实例对象作为 sort 方法第二个参数传入，实现排序，如下：
public class KeyComparator implements Comparator<Integer> {
@Override
public int compare(Integer v1, Integer v2) {
return v1 - v2;
}
}
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, new KeyComparator());
System.out.println(keys); // [2, 3, 5, 9, 10]
复制代码
后来，这种写法比较麻烦，于是用匿名内部类改写这种写法，我们不需要自己去编写一个类来实现这个接口了，直接用匿名内部类。就是这种写法：
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, new Comparator<Integer>() {
@Override
public int compare(Integer v1, Integer v2) {
return v1 - v2;
}
});
System.out.println(keys); // [2, 3, 5, 9, 10]
复制代码
现在，匿名内部类比起 Lambda 表达式，也是麻烦，我们用 Lambda 进行改写：
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
Collections.sort(keys, (Integer v1, Integer v2) -> {return v1 - v2;});
System.out.println(keys); // [2, 3, 5, 9, 10]
复制代码
是吧，(Integer v1, Integer v2) -> {return v1 - v2;} 的写法，没有函数名，也能进行调用。
实际上，这样还不是最简的，最简的是这样：(v1, v2) -> v1 - v2
是不是很好奇啥时候能这样写？现在就告诉你！
基本语法(参数类型 参数名) -> { 方法体 }
基本上，这样写，是不会有问题的。下面说说何时能写得更加简单。
为了便于阅读，下面的「方法」指的是函数式接口中的抽象方法
- 方法没有参数，那么可以直接写小括号，然后箭头，再写中括号，最后写方法体，即 () -> { 方法体 }
- 方法有多个参数，那么多个参数就用逗号分开，同时参数类型是可以省略的，即 (v1, v2, ...) -> {方法体}
- 方法只有一个参数，那么小括号可以去掉，直接写参数名，然后箭头，再中括号和方法体，即 v -> {方法体}
- 方法体只有一条语句，无论是否有返回值，都可以省略大括号、return 关键字及语句分号。
常见的就是 Runnable 接口了。
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
复制代码
- 未使用 Lambda（使用匿名内部类）：
new Thread(new Runnable() {
@Override
void run() {
System.out.println("线程开始跑了");
}
}).start();
复制代码
- 使用 Lambda：
// 写法一
new Thread(() -> {
System.out.println("线程开始跑了")
}).start();
// 写法二，一条语句，那么省略大括号、return 关键字及语句分号
new Thread(() -> System.out.println("线程开始跑了")).start();
复制代码情况二：方法无参数，有返回值
例子：Callable 接口
@FunctionalInterface
public interface Callable<V> {
V call() throws Exception;
}
复制代码
- 未使用 Lambda（使用匿名内部类）：
FutureTask<String> stringFutureTask = new FutureTask<>(new Callable<String>() {
@Override
public String call() throws Exception {
return "这里是返回值";
}
});
stringFutureTask.run();
System.out.println(stringFutureTask.get());
复制代码
- 使用 Lambda：
// 一条语句，省略大括号、return 关键字及语句分号
FutureTask<String> stringFutureTask = new FutureTask<>(() -> "这里是返回值");
stringFutureTask.run();
System.out.println(stringFutureTask.get());
复制代码情况三：方法一个参数、有返回值
我随便找了 JDK 中的一个接口，如下：
@FunctionalInterface
interface Recognizer {
boolean recognize(int c);
}
复制代码
- 未使用 Lambda（使用匿名内部类）：
private final Recognizer A = new Recognizer() {
@Override
public boolean recognize(int c) {
return c == 'a' || c == 'A';
}
}
复制代码
- 使用 Lambda：
private final Recognizer A = (c) -> c == 'a' || c == 'A';
// 一个参数，可省略小括号
private final Recognizer A = c -> c == 'a' || c == 'A';
复制代码情况四：方法多个参数、有返回值
直接举 Comparator 这个例子。
- 未使用 Lambda（使用匿名内部类）：
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
keys.sort(new Comparator()<Integer> {
@Override
public int compare(Integer v1, Integer v2) {
return v1 - v2;
}
});
复制代码
- 使用 Lambda：
List<Integer> keys = Arrays.asList(9, 3, 5, 10, 2);
// 多个参数以逗号分开，可省略类型，一条语句，省略大括号、return 关键字及语句分号
keys.sort((v1, v2) -> v1 - v2);
System.out.println(keys);
复制代码总结
到这里，相信大家对于 Lambda 表达式有了一个基本的认识。总的来说：
- 必须是函数式接口才能使用 Lambda 表达式
语法：(参数类型 参数名称) ‐> { 方法体 }
- 若方法的参数列表：没有参数，则可直接用 () ；有一个参数，可以省略 ()，直接写参数；有多个参数，则()不可省略() 内的参数类型可以省略
- 若方法体：只有一条语句，无论是否有返回值，都可以省略大括号、return 关键字及语句分号。处理逻辑过于臃肿复杂，还是使用具体子类改写较好，保证可读性。
由本人水平所限，难免有错误以及不足之处， 屏幕前的靓仔靓女们 如有发现，恳请指出！
最后，谢谢你看到这里，谢谢你认真对待我的努力，希望这篇博客对你有所帮助！
你轻轻地点了个赞，那将在我的心里世界增添一颗明亮而耀眼的星！
