由于第三章的内容比较多，而且为了让大家更好的了解Lambda表达式的使用，也写了一些相关的实例，可以在Github或者码云上拉取读书笔记的代码进行参考。

类型检查、类型推断以及限制

当我们第一次提到Lambda表达式时，说它可以为函数式接口生成一个实例。然而，Lambda表达式本身并不包含它在实现哪个函数式接口的信息。为了全面了解Lambda表达式，你应该知道Lambda的实际类型是什么。

类型检查

Lambda的类型是从使用Lambda上下文推断出来的。上下文（比如，接受它传递的方法的参数，或者接受它的值得局部变量）中Lambda表达式需要类型称为目标类型。

同样的Lambda，不同的函数式接口

有了目标类型的概念，同一个Lambda表达式就可以与不同的函数接口关联起来，只要它们的抽象方法能够兼容。比如，前面提到的Callable，这个接口代表着什么也不接受且返回一个泛型T的函数。

同一个Lambda可用于多个不同的函数式接口：

Comparator<Apple> c1 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
ToIntBiFunction<Apple, Apple> c2 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
BiFunction<Apple, Apple, Integer> c3 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());;

是的，ToIntFunction和BiFunction都是属于函数式接口。还有很多类似的函数式接口，有兴趣的可以去看相关的源码。

到目前为止，你应该能够很好的理解在什么时候以及在哪里使用Lambda表达式了。它们可以从赋值的上下文、方法调用（参数和返回值），以及类型转换的上下文中获得目标类型。为了更好的了解Lambda表达的时候方式，我们来看看下面的例子，为什么不能编译：

Object o = () -> {System.out.println("Tricky example");};

答案：很简单，我们都知道Object这个类并不是一个函数式接口，所以它不支持这样写。为了解决这个问题，我们可以把Object改为Runnable，Runnable是一个函数式接口，因为它只有一个抽象方法，在上一节的读书笔记中我们有提到过它。

Runnable r = () -> {System.out.println("Tricky example");};

你已经见过如何利用目标类型来检查一个Lambda是否可以用于某个特定的上下文。其实，它也可以用来做一些略有不同的事情：tuiduanLambda参数的类型。

类型推断

我们还可以进一步的简化代码。Java编译器会从上下文（目标类型）推断出用什么函数式接口来匹配Lambda表达式，这意味着它也可以推断出适合Lambda的签名，因为函数描述符可以通过目标类型来得到。这样做的好处在于，编译器可以了解Lambda表达式的参数类型，这样就可以在Lambda与法中省去标注参数类型。换句话说，Java编译器会向下面这样推断Lambda的参数类型：

// 参数a没有显示的指定类型
List<Apple> greenApples = filter(apples, a -> "green".equals(a.getColor()));

Lambda表达式有多个参数，代码可独行的好处就更为明显。例如，你可以在这用来创建一个Comparator对象：

// 没有类型推断，显示的指定了类型
Comparator<Apple> cApple1 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

// 有类型推断，没有现实的指定类型
Comparator<Apple> cApple2 = (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

有时候，指定类型的情况下代码更易读，有时候去掉它们也更易读。并没有说哪个就一定比哪个好，需要根据自身情况来选择。

使用局部变量

我们迄今为止所介绍的所有Lambda表达式都只用到了其主体里的参数。但Lambda表达式也允许用外部变量，就像匿名类一样。他们被称作捕获Lambda。例如：下面的Lambda捕获了portNumber变量：

int portNumber = 6666;
Runnable r3 = () -> System.out.println(portNumber);

尽管如此，还有一点点小麻烦：关于能对这些变量做什么有一些限制。Lambda可以没有限制地捕获（也就是在主体中引用）实例变量和静态变量。但局部变量必须显示的声明final，或实际上就算final。换句话说，Lambda表达式只能捕获指派给它们的局部变量一次。（注：捕获实例变量可以被看作捕获最终局部变量this）。例如，下面的代码无法编译。

int portNumber = 6666;
Runnable r3 = () -> System.out.println(portNumber);
portNumber = 7777;

portNumber是一个final变量，尽管我们没有显示的去指定它。但是，在代码编译的时候，编译器会自动给这个变量加了一个final，起码我看反编译后的代码是有一个final的。

对于局部变量的限制

你可能会有一个疑问，为什么局部变量会有这些限制。第一个，实例变量和局部变量背后的实现有一个关键不同。实例变量都存储在堆中，而局部变量则保存在栈上。如果Lambda可以直接访问局部变量，而且Lambda是在一个线程中使用，则使用Lambda的线程，可能会在分配该变量的线程将这个变量回收之后，去访问该变量。因此，Java在访问自由局部变量是，实际上是在访问它的副本，而不是访问原始变量。如果局部变量仅仅复制一次那就没什么区别了，因此就有了这个限制。

现在，我们来了解你会在Java8代码中看到的另一个功能：方法引用。可以把它们视为某些Lambda的快捷方式。

方法引用

方法引用让你可以重复使用现有的方法，并像Lambda一样传递它们。在一些情况下，比起用Lambda表达式还要易读，感觉也更自然。下面就是我们借助Java8 API，用法引用写的一个排序例子：

// 之前
apples.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
// 之后，方法引用
apples.sort(Comparator.comparing(Apple::getWeight));

酷，使用::的代码看起来更加简洁。在此之前，我们也有使用到过，它的确看起来很简洁。

管中窥豹

方法引用可以被看作仅仅调用特定方法的Lambda的一种快捷写法。它的基本思想是，如果一个Lambda代表的只是：“直接调用这个方法”，那最好还是用名称来调用它，而不是去描述如何调用它。事实上，方法引用就是让你根据已有的方法实现来创建Lambda表达式。但是，显示地指明方法的名称，你的代码可读性会更好。它是如何工作的？当你需要使用方法引用是，目标引用放在分隔符::前，方法的名称放在后面。 例如，Apple::getWeight就是引用了Apple类中定义的getWeight方法。请记住，不需要括号，因为你没有实际调用这个方法。方法引用就是用Lambda表达式(Apple a) -> a.getWeight()的快捷写法。

我们接着来看看关于Lambda与方法引用等效的一些例子:

Lambda:(Apple a) -> a.getWeight() 
方法引用:Apple::getWeight

Lambda:() -> Thread.currentThread().dumpStack() 
方法引用:Thread.currentThread()::dumpStack

Lambda:(str, i) -> str.substring(i)
方法引用:String::substring

Lambda:(String s) -> System.out.println(s)
方法引用:System.out::println

你可以把方法引用看作是Java8中个一个语法糖，因为它简化了一部分代码。

构造函数引用

对于一个现有的构造函数，你可以利用它的名称和关键字new来创建它的一个引用:ClassName::new。如果，一个构造函数没有参数，那么可以使用Supplier来创建一个对象。你可以这样做:

Supplier<Apple> c1 = Apple::new;
Apple apple = c1.get();

这样做等价于

Supplier<Apple> c1 = () -> new Apple();
Apple apple = c1.get();

如果，你的构造函数的签名是Apple(Integer weight)，那么可以使用Function接口的签名，可以这样写:

Function<Integer, Apple> c2 = Apple::new;
Apple a2 = c2.apply(120);

这样做等价于

Function<Integer, Apple> c2 = (weight) -> new Apple(weight);
Apple a2 = c2.apply(120);

如果有两个参数Apple(weight, color)，那么我们可以使用BiFunction:

BiFunction<Integer, String, Apple> c3 = Apple::new;
Apple a3 = c3.apply(120, "red");

这样做等价于

BiFunction<Integer, String, Apple> c3 =(weight, color) -> new Apple(weight, color);
Apple a3 = c3.apply(120, "red");

到目前为止，我们了解到了很多新内容：Lambda、函数式接口和方法引用，接下来我们将把这一切付诸实践。

Lambda和方法引用实战

为了更好的熟悉Lambda和方法引用的使用，我们继续研究开始的那个问题，用不同的排序策略给一个Apple列表排序，并需要展示如何把一个圆使出报的解决方案变得更为简明。这会用到我们目前了解到的所有概念和功能：行为参数化、匿名类、Lambda表达式和方法引用。我们想要实现的最终解决方案是这样的:

apples.sort(comparing(Apple::getWeight));

第1步：代码传递

很幸运，Java8的Api已经提供了一个List可用的sort方法，我们可以不用自己再去实现它。那么最困难部分已经搞定了！但是，如果把排序策略传递给sort方法呢？你看，sort方法签名是这样的：

void sort(Comparator<? super E> c)

它需要一个Comparator对象来比较两个Apple！这就是在Java中传递策略的方式：它们必须包裹在一个对象利。我们说sort的行为被参数化了了：传递给他的排序策略不同，其行为也会不同。

可能，你的第一个解决方案是这样的:

public class AppleComparator implements Comparator<Apple> {
    @Override
    public int compare(Apple o1, Apple o2) {
        return o1.getWeight().compareTo(o2.getWeight());
    }
}

apples.sort(new AppleComparator());

它确实能实现排序，但是还需要去实现一个接口，并且排序的规则也不复杂，或许它还可以简化一下。

第2步：使用匿名类

或许你已经想到了一个简化代码的办法，就是使用匿名类而且每次使用只需要实例化一次就可以了：

apples.sort(new Comparator<Apple>() {
    @Override
    public int compare(Apple o1, Apple o2) {
        return o1.getWeight().compareTo(o2.getWeight());
    }
});

看上去确实简化一些，但感觉还是有些啰嗦，我们接着继续简化:

第3步：使用Lambda表达式

我们可以使用Lambda表达式来替代匿名类，这样可以提高代码的简洁性和开发效率：

apples.sort((o1, o2) -> o1.getWeight().compareTo(o2.getWeight()));

太棒了！这样的代码看起来很简洁，原来四五行的代码只需要一行就可以搞定了！但是，我们还可以使这行代码更加的简洁！

第4步：使用方法引用

使用Lambda表达式的代码确实简洁了不少，那你还记得我们前面说的方法引用吗？它是Lambda表达式的一种快捷写法，相当于是一种语法糖，那么我们来试试糖的滋味如何：

apples.sort(Comparator.comparing(Apple::getWeight));

恭喜你，这就是你的最终解决方案！这样的代码比真的很简洁，这比Java8之前的代码好了很多。这样的代码比较简短，它的意思也很明显，并且代码读起来和问题描述的差不多：“对库存进行排序，比较苹果的重量”。

复合（组合）Lambda表达式的有用方法

Java8的好几个函数式接口都有为方便而设计的的方法。具体而言，许多函数式接口，比如用于传递Lambda表达式的Comparator、Function和Predicate都提供了允许你进行复合的方法。这是什么意思呢？在实践中，这意味着你可以把多个简单的Lambda复合成复杂的表达式。比如，你可以让两个谓词之间做一个or操作，组合成一个更大的谓词。而且，你还可以让一个函数的结果成为另一个函数的输入。你可能会想，函数式接口中怎么可能有更多的方法？（毕竟，这违背了函数式接口的定义，只能有一个抽象方法）还记得我们上一节笔记中提到默认方法吗？它们不是抽象方法。关于默认方法，我们以后在进行详细的了解吧。

比较复合器

还记刚刚我们对苹果的排序吗？它只是一个从小到大的一个排序，现在我们需要让它进行逆序。看看刚刚方法引用的代码，你会发现它貌似无法进行逆序啊！不过不用担心，我们可以让它进行逆序，而且很简单。

1.逆序

想要实现逆序其实很简单，需要使用一个reversed()方法就可以完成我们想要的逆序排序:

apples.sort(Comparator.comparing(Apple::getWeight).reversed());

按重量递减排序，就这样完成了。这个方法很有用，而且用起来很简单。

2.比较器链

上面的代码很简单，但是你仔细想想，如果存在两个一样重的苹果谁前谁后呢？你可能需要再提供一个Comparator来进一步定义这个比较。比如，再按重量比较了两个苹果之后，你可能还想要按原产国进行排序。thenComparing方法就是做这个用的。它接受一个函数作为参数（就像comparing方法一样），如果两个对象用第一个Comparator比较之后还是一样，就提供第二个Comparator。我们又可以优雅的解决这个问题了：

apples.sort(Comparator.comparing(Apple::getWeight).reversed()
                .thenComparing(Apple::getCountry));

复合谓词

谓词接口包括了三个方法: negate、and和or，让你可以重用已有的Predicate来创建更复杂的谓词。比如，negate方法返回一个Predicate的非，比如苹果不是红的：

private static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.test(t)) {
            result.add(t);
        }
    }
    return result;
}

List<Apple> apples = Arrays.asList(new Apple(150, "red"), new Apple(110, "green"), new Apple(100, "green"));
// 只要红苹果
Predicate<Apple> apple = a -> "red".equals(a.getColor());
// 只要红苹果的非
Predicate<Apple> notRedApple = apple.negate();
// 筛选
List<Apple> appleList = filter(apples, notRedApple);
// 遍历打印
appleList.forEach(System.out::println);

你可能还想要把Lambda用and方法组合起来，比如一个苹果即是红色的又比较重：

Predicate<Apple> redAndHeavyApple = apple.and(a -> a.getWeight() >= 150);

你还可以进一步组合谓词，表达要么是重的红苹果，要么是绿苹果：

 Predicate<Apple> redAndHeavyAppleOrGreen =
                apple.and(a -> a.getWeight() >= 150)
                        .or(a -> "green".equals(a.getColor()));

这一点为什么很好呢？从简单的Lambda表达式出发，你可以构建更复杂的表达式，但读起来仍然和问题陈述的差不多！请注意，and和or方法是按照表达式链中的位置，从左向右确定优先级的。因此，a.or(b).and(c)可以看作(a || b) && c。

函数复合

最后，你还可以把Function接口所代表的Lambda表达式复合起来。Function接口为此匹配了andThen和compose两个默认方法，它们都会返回Function的一个实例。

andThen方法会返回一个函数，它先对输入应用一个给定函数，再对输出应用另一个函数。假设，有一个函数f给数字加1(x -> x + 1)，另外一个函数g给数字乘2，你可以将它们组合成一个函数h：

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = f.andThen(g);
// result = 4
int result = h.apply(1);

你也可以类似地使用compose方法，先把给定的函数左右compose的参数里面给的那个函数，然后再把函数本身用于结果。比如在上一个例子用compose的化，它将意味着f(g(x))，而andThen则意味着g(f(x)):

Function<Integer, Integer> f1 = x -> x + 1;
Function<Integer, Integer> g1 = x -> x * 2;
Function<Integer, Integer> h1 = f1.compose(g1);
// result1 = 3
int result1 = h1.apply(1);

它们的关系如下图所示:

compose和andThen的不同之处就是函数执行的顺序不同。compose函数限制先参数，然后执行调用者，而andThen限制先调用者，然后再执行参数。

总结

在《Java8实战》第三章中，我们了解到了很多概念关键的念。

1. Lambda表达式可以理解为一种匿名函数：它没有名称，但有参数列表、函数主体、返回类型，可能还有一个可抛出的异常列表。
2. Lambda表达式让我们可以简洁的传递代码。
3. 函数式接口就是仅仅只有一个抽象方法的接口。
4. 只有在接受函数式接口的地方才可以使用Lambda表达式。
5. Lambda表达式允许你直接内联，为函数式接口的抽象方法提供实现，并且将整个表达式作为函数式接口的一个实例。
6. Java8自带一些常用的函数式接口，在java.util.function包里，包括了Predicate、Function、Supplier、Consumer和BinaryOperatory。
7. 为了避免装箱操作，等于Predicate和Function等通用的函数式接口的原始类型特化：IntPredicate、IntToLongFunction等。
8. Lambda表达式所需要代表的类型称为目标类型。
9. 方法引用可以让我们重复使用现有的方法实现并且直接传递它们。
10. Comparator、Predicate和Function等函数式接口都有几个可以用来结合Lambda表达式的默认方法。

第三章的内容确实很多，而且这一章的内容也很重要，如果你有兴趣那么请慢慢的看，最好自己能动手写写代码否则过不了多久就会忘记了。

第三章笔记中的代码：

Github: chap3

Gitee: chap3

如果，你对Java8中的新特性很感兴趣，你可以关注我的公众号或者当前的技术社区的账号，利用空闲的时间看看我的文章，非常感谢！