定义
Java 表达式有很多种，声明一个class是一个表达式，定义一个变量是一个表达式，写一个=赋值逻辑是一个表达式……
Lambda表达式是这样一个表达式：
lambdaParameters -> lambdaBody
在lambdaParameters传递参数，在lambdaBody中编写逻辑。lambda表达式生成的结果就是一个函数式接口（上文提到过的）。lambdaBody中的逻辑内容（各种表达式）不会在定义时执行，在实际函数式接口调用时才会执行。
举几个官方的例子看看：
() -> {} // No parameters; result is void
() -> 42 // No parameters, expression body
() -> null // No parameters, expression body
() -> { return 42; } // No parameters, block body with return
() -> { System.gc(); } // No parameters, void block body
() -> { // Complex block body with returns
if (true) return 12;
else {
int result = 15;
for (int i = 1; i < 10; i++)
result *= i;
return result;
}
}
(int x) -> x+1 // Single declared-type parameter
(int x) -> { return x+1; } // Single declared-type parameter
(x) -> x+1 // Single inferred-type parameter
x -> x+1 // Parentheses optional for
// single inferred-type parameter
(String s) -> s.length() // Single declared-type parameter
(Thread t) -> { t.start(); } // Single declared-type parameter
s -> s.length() // Single inferred-type parameter
t -> { t.start(); } // Single inferred-type parameter
(int x, int y) -> x+y // Multiple declared-type parameters
(x, y) -> x+y // Multiple inferred-type parameters
(x, int y) -> x+y // Illegal: can't mix inferred and declared types
(x, final y) -> x+y // Illegal: no modifiers with inferred types
AI 代码解读
lambda表达式的参数部分
可以通过上面的例子看到，lambda的参数声明主要包含两大类，一类是声明类型的，一类是不声明类型的（依赖推断的）。其中声明类型的参数，与定义一个方法时声明参数是一样的。
几个注意的点：
- _不能作为lambda参数。
- int...与int[]是一致的。
- 当参数是推断类型时，注意推断类型的类型转换错误，类型是依据上下文变化的。
来个推断的例子：
Function inferedFunc = x -> {
System.out.println(x.getClass().getTypeName());
return x.toString();
};
Object a = inferedFunc.apply(10);
Object b = inferedFunc.apply(100D);
AI 代码解读
lambda表达式的body部分
body部分的形式同一个方法的描述基本一致，或者是一个表达式，或者是一个block代码。整体理解lambda的参数和body，可以对应上一节的Function接口来看：()的参数部分，对应Function的第一个泛型参数；{}或者类似x+1这样的表达式作为body，对应Function的第二个泛型参数。空参数对应Supplier，而空return对应Consumer。
不同于匿名内部类的形式，lambda表达式的body共享上下文类的this变量。另一个注意点是lambda表达式的body里包含的外部变量，变量需要是final的或者effectively final。
effectively final的定义如下：
-
如果是有初始值的变量（赋值过一次），需要满足：
- 没有声明final
- 从未出现在赋值语句的左值部分
- 从未作为一个变量被++或--之类的递增递减形式操作过
-
如果是没有初始值的变量，需要满足：
- 没有声明final
- 在实际赋值前，绝对未赋值或者未绝对赋值
- 从未作为一个变量被++或--之类的递增递减形式操作过
- 方法、构造函数、lambda和异常的参数，会被认为是effectively final
这里又引入两个概念：绝对赋值和绝对未赋值。
- 绝对赋值：变量在复杂逻辑中的每个执行路径中都保证赋值语句存在。
- 绝对未赋值：变量在复杂逻辑中的每个执行路径中都保证没有赋值语句存在。
看个例子：（绝对赋值，需要注释掉n=6）
{
int k;
while (true) {
k = n;
if (k >= 5) break; //这里之前是绝对赋值
n = 6; //如果n=2，那么k需要被赋值两次，就不是绝对赋值
}
System.out.println(k);
}
AI 代码解读
不满足绝对赋值：
{
int k;
while (n < 4) {
k = n;
if (k >= 5) break;
n = 6;
}
System.out.println(k); /* k is not "definitely assigned"
before this statement */
}
AI 代码解读
绝对未赋值：
void unflow(boolean flag) {
final int k;
if (flag) {
k = 3;
System.out.println(k);
}
else {
k = 4;
System.out.println(k);
}
}
AI 代码解读
不满足绝对未赋值：
void unflow(boolean flag) {
final int k;
if (flag) {
k = 3;
System.out.println(k);
}
if (!flag) {
k = 4;
System.out.println(k); /* k is not "definitely unassigned"
before this statement */
}
}
AI 代码解读
body部分也表达出了一部分兼容性，即当body部分是表达式语句时，如果语句允许独立执行，那么该表达式等价于body部分是void返回值的。即如下的例子，list.add是个返回boolean的方法，因为可以独立执行，那么下面的例子都是OK的：
List list = new ArrayList();
// Predicate has a boolean result
java.util.function.Predicate<String> p = s -> list.add(s);
// Consumer has a void result
java.util.function.Consumer<String> c = s -> list.add(s);
AI 代码解读
方法引用
方法引用表达式是另一类执行函数式接口的模式，在Java 8之前是没有能力表达一个函数方法的，在Java 8引入函数式接口后，每个lambda表达式都代表了一个函数，可以指向性的将lambda表达式赋值给一个Function类的接口。另一个重要的方法就是直接使用函数方法引用。
方法引用是通过[对象名]::[方法名]这种模式来引用的，其中::两个冒号的操作符非常重要。具体的场景针对类、对象实例、数组、泛型等均有不同的支持，下面的例子看看各种方法引用的表达方式：
public class TestJ8MethodReference {
public static void main(String[] args) {
// static method
Function<Integer, Integer> f1 = TestJ8MethodReference::add;
System.out.println(f1.apply(1));
// instance method
Function<String, String> f2 = String::trim;
System.out.println(f2.apply(" abd b"));
TestJ8MethodReference testJ8MethodReference = new TestJ8MethodReference();
Function<Integer, String> f3 = testJ8MethodReference::getStr;
System.out.println(f3.apply(3));
// super
testJ8MethodReference.testSuper();
// explicit type arguments for generic type
testJ8MethodReference.testExplicitType();
// implicit type arguments for generic type
testJ8MethodReference.testImplicitType();
// new
Supplier s1 = TestJ8MethodReference::new;
System.out.println(s1.get());
// type arguments inferred from context
Consumer<int[]> c1 = Arrays::sort;
int[] array = new int[]{4, 3, 2, 1};
c1.accept(array);
// explicit type arguments
Consumer<int[]> c2 = Arrays::<int[]>sort;
c2.accept(array);
// new array
Function<Integer, int[]> f4 = (int[]::new);
int[] a = f4.apply(10);
System.out.println(a.length);
}
public static int add(int x) {
return x + 1;
}
public String getStr(int x) {
return "" + x;
}
public void testSuper() {
Supplier<String> f = super::toString;
System.out.println(f.get());
}
public void testExplicitType() {
List<String> list = new ArrayList<>();
Function<String, Boolean> func = list::add;
System.out.println(func.apply("a"));
}
public void testImplicitType() {
List list = new ArrayList();
Function<String, Boolean> func = list::add;
System.out.println(func.apply("a"));
}
}
AI 代码解读
其中需要注意的是，数组的new方法引用等价于一个有入参的Function，因为new一个数组是需要指定size的。
总结
无论lambda表达式还是方法引用表达式，所指向的都是一个方法或者是函数。而它们指向的内容能赋值的也一定是函数式接口。这两种指向也是实用场景各异，方法引用需要使用在已有方法上（显而易见），而lambda表达式是一种快速行内声明一个方法且指向一个函数式接口的方法。两者交互配合，基本可以覆盖各种函数式接口使用的场景。
