Java 8中有效的Lambda表达式:
Java语言设计者选择这样的语法，是因为C#和Scala等语言中的类似功能广受欢迎。
Lambda的基本语法是:
(parameters) -> expression
或（请注意语句的花括号）
(parameters) -> { statements; }
Lambda仅可用于上下文是函数式接口的情况.
函数式接口就是只定义一个抽象方法的接口
public interface Predicate<T>{
boolean test (T t);
}
Java API中的一些其他函数式接口:
public interface Comparator<T> {
int compare(T o1, T o2);
}
public interface Runnable{
void run();
}
public interface ActionListener extends EventListener{
void actionPerformed(ActionEvent e);
}
public interface Callable<V>{
V call();
}
public interface PrivilegedAction<V>{
V run();
}
函数描述符
函数式接口的抽象方法的签名基本上就是Lambda表达式的签名。我们将这种抽象方法叫作函数描述符。
一套能够描述常见函数描述符的函数式接口: (java.util.function包中引入了几个新的函数式接口)
Java API中已经有了几个函数式接口，比如 Comparable、 Runnable和Callable。
Java类型要么是引用类型（比如Byte、 Integer、 Object、 List） ，要么是原始类型（比如int、 double、 byte、 char）。但是泛型（比如Consumer<T>中的T）只能绑定到引用类型 -- 这是由泛型内部的实现方式造成的。
但这在性能方面是要付出代价的。装箱后的值本质上就是把原始类型包裹起来，并保存在堆里。因此，装箱后的值需要更多的内存，并需要额外的内存搜索来获取被包裹的原始值。
Java 8为我们前面所说的函数式接口带来了一个专门的版本，以便在输入和输出都是原始类型时避免自动装箱的操作。比如，在下面的代码中，使用IntPredicate就避免了对值1000进行装箱操作，但要是用Predicate<Integer>就会把参数1000装箱到一个Integer对象中：
public interface IntPredicate{
boolean test(int t);
}
IntPredicate evenNumbers = (int i) -> i % 2 == 0;
evenNumbers.test(1000); // 无装箱操作
Predicate<Integer> oddNumbers = (Integer i) -> i % 2 == 1;
oddNumbers.test(1000); // 装箱操作
Java 8中的常用函数式接口
请记住， (T,U) -> R的表达方式展示了应当如何思考一个函数描述符。表的左侧代表了参数类型。这里它代表一个函数，具有两个参数，分别为泛型T和U，返回类型为R。
异常、 Lambda，还有函数式接口又是怎么回事呢？
请注意，任何函数式接口都不允许抛出受检异常（checked exception）。如果你需要Lambda表达式来抛出异常，有两种办法：定义一个自己的函数式接口，并声明受检异常，或者把Lambda包在一个try/catch块中。比如，在3.3节我们介绍了一个新的函数式接口BufferedReaderProcessor，它显式声明了一个IOException：
@FunctionalInterface
public interface BufferedReaderProcessor {
String process(BufferedReader b) throws IOException;
}
BufferedReaderProcessor p = (BufferedReader br) -> br.readLine();
但是你可能是在使用一个接受函数式接口的API，比如Function<T, R>，没有办法自己创建一个（你会在下一章看到， Stream API中大量使用表3-2中的函数式接口）。这种情况下，你可以显式捕捉受检异常：
Function<BufferedReader, String> f = (BufferedReader b) -> {
try {
return b.readLine();
}
catch(IOException e) {
throw new RuntimeException(e);
}
};
类型检查
Lambda的类型是从使用Lambda的上下文推断出来的。上下文（比如，接受它传递的方法的参数，或接受它的值的局部变量）中Lambda表达式需要的类型称为目标类型.
实例说明：
List<Apple> heavierThen150g =
filter(inventory, (Apple a) -> a.getWeight() > 150 );
public interface Predicate<T>{ // Apple -> boolean 接受Apple 返回 boolean
boolean test(T);
}
类型检查过程可以分解为如下所示。sec.3.5 page: 70/374 <<Java8 in action>>
首先，你要找出filter方法的声明。
第二，要求它是Predicate<Apple>（目标类型）对象的第二个正式参数。
第三， Predicate<Apple>是一个函数式接口，定义了一个叫作test的抽象方法。
第四， test方法描述了一个函数描述符，它可以接受一个Apple，并返回一个boolean。
最后， filter的任何实际参数都必须匹配这个要求。
同样的 Lambda，不同的函数式接口
有了目标类型的概念，同一个Lambda表达式就可以与不同的函数式接口联系起来，只要它们的抽象方法签名能够兼容。比如，前面提到的Callable和PrivilegedAction，这两个接口都代表着什么也不接受且返回一个泛型T的函数。 因此，下面两个赋值是有效的：
Callable<Integer> c = () -> 42;
PrivilegedAction<Integer> p = () -> 42;
菱形运算符
Java 7中已经引入了菱形运算符（<>），利用泛型推断从上下文推断类型的思想（这一思想甚至可以追溯到更早的泛型方法）。一个类实例表达式可以出现在两个或更多不同的上下文中，并会像下面这样推断出适当的类型参数：
List<String> listOfStrings = new ArrayList<>();
List<Integer> listOfIntegers = new ArrayList<>();
特殊的void兼容规则
如果一个Lambda的主体是一个语句表达式， 它就和一个返回void的函数描述符兼容（当然需要参数列表也兼容）。例如，以下两行都是合法的，尽管List的add方法返回了一个boolean，而不是Consumer上下文（T -> void）所要求的void：
// Predicate返回了一个boolean
Predicate<String> p = s -> list.add(s);
// Consumer返回了一个void
Consumer<String> b = s -> list.add(s);
Lambda表达式: 可以从赋值的上下文、方法调用的上下文（参数和返回值），以及类型转换的上下文中获得目标类型。
类型检查——为什么下面的代码不能编译呢？ 你该如何解决这个问题呢？
Object o = () -> {System.out.println("Tricky example"); };
答案： Lambda表达式的上下文是Object（目标类型）。但Object不是一个函数式接口。为了解决这个问题，你可以把目标类型改成Runnable，它的函数描述符是() -> void：
Runnable r = () -> {System.out.println("Tricky example"); };
类型推断
Java编译器会从上下文（目标类型）推断出用什么函数式接口来配合Lambda表达式，这意味着它也可以推断出适合Lambda的签名，因为函数描述符可以通过目标类型来得到。这样做的好处在于，编译器可以了解Lambda表达式的参数类型，这样就可以在Lambda语法中省去标注参数类型。
List<Apple> greenApples =
filter(inventory, a -> "green".equals(a.getColor())); // a 没有显示类型
Comparator<Apple> c =
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()); //没有类型推断
Comparator<Apple> c =
(a1, a2) -> a1.getWeight().compareTo(a2.getWeight()); // a1, a2 有类型推断
使用局部变量
Lambda表达式也允许使用自由变量（不是参数，而是在外层作用域中定义的变量），就像匿名类一样。 它们被称作捕获Lambda。例如，下面的Lambda捕获了portNumber变量：
int portNumber = 1337;
Runnable r = () -> System.out.println(portNumber);
尽管如此，还有一点点小麻烦：关于能对这些变量做什么有一些限制。 Lambda可以没有限制地捕获（也就是在其主体中引用）实例变量和静态变量。但局部变量必须显式声明为final，或事实上是final。换句话说， Lambda表达式只能捕获指派给它们的局部变量一次。（注：捕获实例变量可以被看作捕获最终局部变量this。） 例如，下面的代码无法编译，因为portNumber 变量被赋值两次：
int portNumber = 1337;
Runnable r = () -> System.out.println(portNumber); <- 错误： Lambda表达式引用的
局部变量必须是最终的（ final）或事实上最终的
portNumber = 31337;
对局部变量的限制
实例变量都存储在堆中，而局部变量则保存在栈上。如果Lambda可以直接访问局部变量，而且Lambda是在一个线程中使用的，则使用Lambda的线程，可能会在分配该变量的线程将这个变量收回之后，去访问该变量。因此， Java在访问自由局部变量时，实际上是在访问它的副本，而不是访问原始变量。如果局部变量仅仅赋值一次那就没有什么区别了——因此就有了这个限制。
闭包
你可能已经听说过闭包（closure，不要和Clojure编程语言混淆）这个词，你可能会想Lambda是否满足闭包的定义。用科学的说法来说，闭包就是一个函数的实例，且它可以无限制地访问那个函数的非本地变量。例如，闭包可以作为参数传递给另一个函数。它也可以访问和修改其作用域之外的变量。现在， Java 8的Lambda和匿名类可以做类似于闭包的事情：
如前所述，这种限制存在的原因在于局部变量保存在栈上，并且隐式表示它们仅限于其所在线程。如果允许捕获可改变的局部变量，就会引发造成线程不安全的新的可能性，而这是我们不想看到的（实例变量可以，因为它们保存在堆中，而堆是在线程之间共享的） 。