Lambda是一段可以传递的代码，可以被多次执行。当然，不使用Lambda表达式也可以写出同样的代码，对比如下，可以看到lambda的写法简洁很多。
public interface Invocable<T,R> {
R invoke(T input);
}
public static void main(String[] args) {
myInvoke("str", new Invocable<String, String>() {
@Override
public String invoke(String input) {
return "MyInvocable#invoke --> " + input;
}
});
myInvoke("str", (input) -> "MyInvocable#invoke --> " + input);
}
private static void myInvoke(String str, Invocable invocable) {
System.out.println(invocable.invoke(str));
}
Lambda语法
Lambda语法格式如下，如果一个表达式无法完整表达逻辑，那就就写成一个代码块，用花括号括起。
(参数...) -> [表达式;代码块]
示例：
//表达式
(String first, String second) -> Integer.compare(first.length(), second.length());
//代码块
(String first, String second) -> {
if (first.length() < second.length()) return -1;
else if (first.length() > second.length()) return 1;
else return 0;
}
//无入参
() -> {
for (int i = 0; i < 10; i++) doSomeThing();
}
//自动推导入参类型
Comparator comp = (first, second) -> Integer.compare(first.length(), second.length());
函数式接口
对于只包含一个抽象方法的接口，就可以通过lambda表达式来创建该接口的对象啦，这种接口就叫做函数式接口。java.util.function包中预定义了好多函数式接口，并且同意标记上了注解【@FunctionalInterface】。自定义的函数式接口也建议加上这个注解，因为编译器会检查该实体，是否只包含一个抽象方法的，同时也更加清晰可读。
例如：
Map<Integer, User> userMap = Stream.of(new User(0, "张三", 18, 0), new User(0, "张四", 19, 0), new User(0, "老张", 20, 1))
.collect(Collectors.toMap(User::getId, item -> item));
这里的toMap方法接收的输入参数就是Function函数：
public static <T, K, U>
Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper) {
其他常见预定义函数的说明可以参见上一篇文章（http://www.atatech.org/articles/61907）
方法引用和构造器引用
方法引用：
//对象::实例方法：
instance::method --> (input1,input2...) -> instance.method(input1,input2...)
//类::静态方法：
class::staticMethod --> (input1,input2...) -> class.staticMethod(input1,input2...)
//类::实例方法：
class::method --> (input1,input2,input3...) -> input1.method(input2,input3...)
构造器引用：
List<String> list = Arrays.asList("a", "b");
list.stream().map(MyClass::new);
构造器引用会自动适配一个合适的构造函数，例如上面的示例会适配一个入参为一个String类型的构造函数。
Lambda的闭包语法糖
在java中原有的闭包：
public static Supplier<Integer> testClosure() {
final int i = 1;
return new Supplier<Integer>() {
@Override
public Integer get() {
return i;
}
};
}
public interface Supplier<T> {
T get();
}
此处变量i是testClosure方法的内部变量，但是我们在匿名内部函数get中却返回了 i；内部变量 i 的生存周期延长了，并且使得变量 i 可以被外部函数所引用，这就是闭包。注意变量 i 必须为final，否则会编译错误。
在Lambda中的闭包：
public static Supplier<Integer> testClosure() {
int i = 1;
//i++;
return () -> {
return i;
};
}
此处 i 不需要定义为final，但是这仅仅是一个语法糖，事实上任何对 i 的value的变更一样会引起语法错误。
延迟执行
lambda表达式都是延迟执行的，如果需要立即执行一段代码，就没必要使用lambda表达式了，就好像如果需要立即执行就没必要使用匿名内部类一样。lambda表达式可以在另一个线程中执行，可以多次运行，按需运行，在某个正确的时机（事件触发，算法运行的某个时间点）运行。
例如，常用的log记录方式如下：
log.info("x:" + x + ",y:" + y);
参数会立即计算完成再传递给info方法，此时会判断日志级别，如果符合info输出才会打印日志，如果为debug等info不输出的情况，会忽略当前信息，但是呢参数已经计算过了。做了一次无用功。此时如果改为lambda延迟执行，则不会出现这种无谓的计算。如下：
log.info(() -> "x:" + x + ",y:" + y);
总结
迟来的特性，哈哈，不过还是带来了很多便利的。