目录
一. 前言
二. lambda 表达式语法
2.1. 语法1：无参，无返回值
2.2. 语法2：一个参数，无返回值
2.3. 语法3：两个参数，lambda 体中有多条语句
2.4. 语法4：两个以上参数，有返回值
三. 函数式接口
3.1. 定义
3.2. 自定义函数式接口
3.3. 内置函数式接口
3.3.1. Consumer 示例
3.3.2. Supplier 示例
3.3.3. Function 示例,>
3.3.4. Predicate 示例
四. 方法引用
4.1. 对象::实例方法名
4.2. 类::静态方法名
4.3. 类::实例方法名
五. 构造器引用和数组引用
5.1. 构造器引用
5.2. 数组引用
六. lambda 表达式的作用域
6.1. 访问局部变量
6.2. 访问局部引用，静态变量，实例变量
6.3. 访问局部变量作限制的原因
七. 总结
一. 前言
咱们首先来说说 lambda 这个名字，lambda 并不是一个什么的缩写，它是希腊第十一个字母 λ 的读音，同时它也是微积分函数中的一个概念，所表达的意思是一个函数入参和出参定义，在编程语言中其实是借用了数学中的 λ，并且多了一点含义，在编程语言中功能代表它具体功能的叫法是匿名函数（Anonymous Function），根据百科的解释：
匿名函数（英语：Anonymous Function）在计算机编程中是指一类无需定义标识符（函数名）的函数或子程序。接着再来说说 lambda 的历史，虽然它在 JDK8 发布之后才正式出现，但是在编程语言界，它是一个具有悠久历史的东西，最早在 1958 年在 Lisp 语言中首先采用，而且虽然 Java 脱胎于 C++，但是 C++ 在2011年已经发布了 lambda 了，但是 JDK8 的 LTS 在2014年才发布，所以 Java 被人叫做老土不是没有原因的，现代编程语言则是全部一出生就自带 lambda 支持，所以 lambda 其实是越来越火的一个节奏。
lambda 在编程语言中往往是一个匿名函数，也就是说 lambda 是一个抽象概念，而编程语言提供了配套支持，比如在 Java 中其实为 lambda 进行配套的就是函数式接口，通过函数式接口生成匿名类和方法进行 lambda 式的处理。那么，既然这一套规则我们明白了，那么 lambda 所提供的好处在 Java 中就是函数式接口所提供的能力了，函数式接口往往则是提供了一些通用能力，这些函数式接口在 JDK 中也有一套完整的实践，那就是 Stream。
lambda 表达式也可称为闭包。类似于JavaScript中的闭包，是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码。它们是一种可传递的匿名函数，可以作为参数传递给方法或存储在变量中，因此可以在需要的时候调用它们。同时，JDK 也提供了大量的内置函数式接口供我们使用，使得 lambda 表达式的运用更加方便、高效。
二. lambda 表达式语法
语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda 运算符或箭头操作符 ，读作 (goes to)，它将 lambda 分为两个部分：
1. 左侧：指定了 lambda 表达式需要的所有参数；
2. 右侧：制定了 lambda 体，即 lambda 表达式要执行的功能。
(parameters) -> expression
// 或
(parameters) -> { statements; }2.1. 语法1：无参，无返回值
无参，无返回值，lambda 体只需一条语句。如下：
public void test01(){
Runnable runnable = () -> System.out.println("Runnable 运行");
runnable.run(); // 结果：Runnable 运行
}2.2. 语法2：一个参数，无返回值
public void test02() {
Consumer<String> consumer = (x) -> System.out.println(x);
consumer.accept("Hello Consumer"); // 结果：Hello Consumer
}
// 参数的小括号可以省略，如下：
public void test02() {
Consumer<String> consumer = x -> System.out.println(x);
consumer.accept("Hello Consumer"); // 结果：Hello Consumer
}2.3. 语法3：两个参数，lambda 体中有多条语句
public void test03() {
Comparator<Integer> com = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
System.out.println(com.compare(2,4)); // 结果：-1
}2.4. 语法4：两个以上参数，有返回值
有两个以上参数，有返回值，若 lambda 体中只有一条语句，return和大括号都可以省略不写。
public void test04() {
Comparator<Integer> com=(Integer x, Integer y) -> Integer.compare(x, y);
System.out.println(com.compare(4, 2)); // 结果：1
}
// 表达式的参数列表的数据类型可以省略不写，因为JVM可以通过上下文推断出数据类型，即“类型推断”
public void test04(){
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
System.out.println(com.compare(4, 2)); // 结果：1
}三. 函数式接口
3.1. 定义
只包含一个抽象方法的接口，就称为函数式接口。我们可以通过 lambda表达式来创建该接口的实现对象。我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以用于检测它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
3.2. 自定义函数式接口
按照函数式接口的定义，自定义一个函数式接口，如下：
@FunctionalInterface
public interface MyFuncInterf<T> {
public T getValue(String origin);
}定义一个方法将函数式接口作为方法参数：
public String toLowerString(MyFuncInterf<String> mf, String origin) {
return mf.getValue(origin);
}将 lambda 表达式实现的接口作为参数传递：
public void test01(){
String value = toLowerString((str) -> {
return str.toLowerCase();
}, "ABC");
System.out.println(value); // 结果ABC
}3.3. 内置函数式接口
四大核心函数式接口的介绍，如下所示：
| 函数式接口 | 参数类型 | 返回类型 | 用途 |
|---|---|---|---|
| Consumer<T> 消费型接口 | T | void | 对类型为 T 的对象应用操作，包含方法：void accept(T t); |
| Supplier<T> 供给型接口 | 无 | T | 返回类型为 T 对象，包含方法：T get(); |
| Function<T, R> 函数型接口 | T | R | 对类型为 T 的对象应用操作，并返回结果，结果是R类型的对象。包含方法：R apply(T t); |
| Predicate<T> 断言型接口 | T | boolean | 确定类型为 T 的对象是否满足某约束，并返回 boolean 值。包含方法：boolean test(T t); |
其他接口的定义，如下所示：
3.3.1. Consumer<T> 示例
public void makeMoney(Integer money, Consumer<Integer> consumer) {
consumer.accept(money);
}
public void test01() {
makeMoney(100, t -> System.out.println("今天赚了" + t)); // 结果：今天赚了100
}3.3.2. Supplier<T> 示例
/**
* 产生指定的整数集合放到集合中
* Iterable接口的forEach方法的定义：方法中使用到了Consumer消费型接口，
* default void forEach(Consumer<? super T> action) {
* Objects.requireNonNull(action);
* for (T t : this) {
* action.accept(t);
* }
* }
*/
public void test01() {
List list = addNumInList(10, () -> (int) (Math.random() * 100));
list.forEach(t -> System.out.println(t));
}
public List addNumInList(int size, Supplier<Integer> supplier) {
List<Integer> list = new ArrayList();
for (int i = 0; i < size; i++) {
list.add(supplier.get());
}
return list;
}3.3.3. Function<T, R> 示例
/**
*
* 使用函数式接口处理字符串。
*/
public String handleStr(String s, Function<String, String> f) {
return f.apply(s);
}
public void test01() {
System.out.println(handleStr("abc", (String s) -> s.toUpperCase()));
}
// 结果：ABC3.3.4. Predicate<T> 示例
/**
* 自定义条件过滤字符串集合
*/
public void test01() {
List<String> strings = Arrays.asList("啊啊啊", "2333", "666", "777");
List<String> stringList = filterStr(strings, (s) -> s.length() > 3);
for (String s : stringList) {
System.out.println(s);
}
}
public List<String> filterStr(List<String> list, Predicate<String> predicate) {
ArrayList result = new ArrayList();
for (int i = 0; i < list.size(); i++) {
if (predicate.test(list.get(i))) {
result.add(list.get(i));
}
}
return result;
}四. 方法引用
当要传递给 lambda 体的操作，已经有实现的方法了，就可以使用方法引用。（实现抽象方法的参数列表，必须与方法引用的参数列表一致，方法的返回值也必须一致，即方法的签名一致）。方法引用可以理解为方法引用是 lambda 表达式的另外一种表现形式。
方法引用的语法，使用操作符“::”将对象或类和方法名分隔开。方法引用的使用情况共分为以下三种：
1. 对象::实例方法名
2. 类::静态方法名
3. 类::实例方法名
4.1. 对象::实例方法名
/**
* PrintStream中的println方法定义
* public void println(String x) {
* synchronized (this) {
* print(x);
* newLine();
* }
* }
*/
// 对象::实例方法名
public void test01() {
PrintStream out = System.out;
Consumer<String> consumer = out::println;
consumer.accept("hello");
}4.2. 类::静态方法名
/**
* Integer类中的静态方法compare的定义：
* public static int compare(int x, int y) {
* return (x < y) ? -1 : ((x == y) ? 0 : 1);
* }
*/
public void test01() {
Comparator<Integer> comparable = (x, y) -> Integer.compare(x, y);
// 使用方法引用实现相同效果
Comparator<Integer> integerComparable = Integer::compare;
System.out.println(integerComparable.compare(4, 2)); // 结果：1
System.out.println(comparable.compare(4, 2)); // 结果：1
}4.3. 类::实例方法名
public void test01() {
BiPredicate<String, String> bp = (x, y) -> x.equals(y);
// 使用方法引用实现相同效果
BiPredicate<String, String> bp2 = String::equals;
System.out.println(bp.test("1", "2")); // 结果：false
System.out.println(bp.test("1", "2")); // 结果：false
}五. 构造器引用和数组引用
5.1. 构造器引用
与函数式接口相结合，自动与函数式接口中方法兼容，可以把构造器引用赋值给定义的方法。需要注意构造器参数列表要与接口中抽象方法的参数列表一致。格式：类名::new。使用示例：
// 实体类Employee
public class Employee {
private Integer id;
private String name;
private Integer age;
public Employee(){
}
public Employee(Integer id) {
this.id = id;
}
public Employee(Integer id, Integer age) {
this.id = id;
this.age = age;
}
public Employee(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}使用构造器引用与函数式接口相结合：
public void test01(){
// 引用无参构造器
Supplier<Employee> supplier = Employee::new;
System.out.println(supplier.get());
// 引用有参构造器
Function<Integer, Employee> function = Employee::new;
System.out.println(function.apply(21));
BiFunction<Integer, Integer, Employee> biFunction = Employee::new;
System.out.println(biFunction.apply(8, 24));
}
输出结果：
Employee{id=null, name='null', age=null}
Employee{id=21, name='null', age=null}
Employee{id=8, name='null', age=24}5.2. 数组引用
数组引用的格式：type[]:new。
public void test01() {
Function<Integer, String[]> function = String[]::new;
String[] apply = function.apply(10);
System.out.println(apply.length); // 结果：10
}六. lambda 表达式的作用域
lambda 表达式可以看作是匿名内部类实例化的对象，lambda 表达式对变量的访问限制和匿名内部类一样，因此 lambda 表达式可以访问局部变量、局部引用，静态变量，实例变量。
6.1. 访问局部变量
在 lambda 表达式中规定只能引用标记了 final 的外层局部变量。我们不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
public class TestFinalVariable {
interface VarTestInterface {
Integer change(String str);
}
public static void main(String[] args) {
// 局部变量不使用final修饰
Integer tempInt = 1;
VarTestInterface var = (str -> Integer.valueOf(str + tempInt));
// 再次修改，不符合隐式final定义
tempInt = 2;
Integer str = var.change("111") ;
System.out.println(str);
}
}上面代码会出现编译错误，出现如下提示：
特殊情况下，局部变量也可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）。例如上面的代码确保 lambda 表达式后局部变量后面不做修改，就可以成功啦！
public class TestFinalVariable {
interface VarTestInterface {
Integer change(String str);
}
public static void main(String[] args) {
// 局部变量不使用final修饰
Integer tempInt = 1;
VarTestInterface var = (str -> Integer.valueOf(str + tempInt));
Integer str = var.change("111") ;
System.out.println(str);
}
}6.2. 访问局部引用，静态变量，实例变量
lambda 表达式不限制访问局部引用变量、静态变量、实例变量。代码测试都可正常执行，代码：
public class LambdaScopeTest {
/**
* 静态变量
*/
private static String staticVar;
/**
* 实例变量
*/
private String instanceVar;
@FunctionalInterface
interface VarChangeInterface {
Integer change(String str);
}
/**
* 测试引用变量
*/
private void testReferenceVar() {
ArrayList<String> list = new ArrayList<>();
list.add("111");
//访问外部引用局部引用变量
VarChangeInterface varChangeInterface = ((str) -> Integer.valueOf(list.get(0)));
//修改局部引用变量
list.set(0, "222");
Integer str = varChangeInterface.change("");
System.out.println(str);
}
/**
* 测试静态变量
*/
void testStaticVar() {
staticVar = "222";
VarChangeInterface varChangeInterface = (str -> Integer.valueOf(str + staticVar));
staticVar = "333";
Integer str = varChangeInterface.change("111") ;
System.out.println(str);
}
/**
* 测试实例变量
*/
void testInstanceVar() {
instanceVar = "222";
VarChangeInterface varChangeInterface = (str -> Integer.valueOf(str + instanceVar));
instanceVar = "333";
Integer str = varChangeInterface.change("111") ;
System.out.println(str);
}
public static void main(String[] args) {
new LambdaScopeTest().testReferenceVar();
new LambdaScopeTest().testStaticVar();
new LambdaScopeTest().testInstanceVar();
}
}// 运行结果：
222
111333
111333lambda 表达式里不允许声明一个与局部变量同名的参数或者局部变量：
// 编程报错
Integer tempInt = 1;
VarTestInterface varTest01 = (tempInt -> Integer.valueOf(tempInt));
VarTestInterface varTest02 = (str -> {
Integer tempInt = 1;
Integer.valueOf(str);
});6.3. 访问局部变量作限制的原因
lambda 表达式不能访问非 final 修饰的局部变量的原因是，局部变量是保存在栈帧中的。而在Java 的线程模型中，栈帧中的局部变量是线程私有的，如果允许 lambda 表达式访问到栈帧中的变量地址（可改变的局部变量），则可能会导致线程私有的数据被并发访问，造成线程不安全问题。
基于上述原因，对于引用类型的局部变量，因为 Java 是值传递的，又因为引用类型的指向内容是保存在堆中，是线程共享的，因此 lambda 表达式中可以修改引用类型的局部变量的内容，而不能修改该变量的引用。
对于基本数据类型的变量，在 lambda 表达式中只是获取到该变量的副本，且局部变量是线程私有的，因此无法知道其他线程对该变量的修改，如果该变量不做 final 修饰，会造成数据不同步的问题。
但是实例变量、静态变量不作限制，因为实例变量，静态变量是保存在堆中（Java8 之后），而堆是线程共享的。在 lambda 表达式内部可以知道实例变量、静态变量的变化。
七. 总结
优点：
1. 使代码更简洁，紧凑；
2. 可以使用并行流来并行处理，充分利用多核CPU的优势；
3. 有利于JIT编译器对代码进行优化。
缺点：
1. 非并行计算情况下，其计算速度没有比传统的 for 循环快；
2. 不容易调试；
3. 若其他程序员没有学过 Lambda 表达式，代码不容易看懂。
关于 lambda 的 Stream 操作，请参见《Java 之 lambda 表达式（二）---- Stream 操作 API》。
