三：Lambda表达式

本章内容

Lambda管中窥豹
在哪里以及如何使用Lambda
环绕执行模式
函数式接口，类型推断
方法引用
Lambda复合

1. lambda管中窥豹

1.1 可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式：它没有名称，但它
有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。这个定义够大的，让我
们慢慢道来。

匿名——我们说匿名，是因为它不像普通的方法那样有一个明确的名称：写得少而想得多！
函数——我们说它是函数，是因为Lambda函数不像方法那样属于某个特定的类。但和方法一样，Lambda有参数列表、函数主体、返回类型，还可能有可以抛出的异常列表
传递——Lambda表达式可以作为参数传递给方法或存储在变量中。
简洁——无需像匿名类那样写很多模板代码。

1.2 lambda表达式可以让你十分简明地传递代码，十分提倡我们使用行为参数化风格。
举例：利用Lambda表达式，你可以更为简洁地自定义一个Comparator对象：

//先前：
Comparator<Apple> byWeight = new Comparator<Apple>() {public int compare(Apple a1, Apple a2){return a1.getWeight().compareTo(a2.getWeight());}
};
//之后（用了Lambda表达式）：
Comparator<Apple> byWeight =(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

1.3 lambda表达式包括三部分：

参数列表——这里它采用了Comparator中compare方法的参数，两个Apple。
箭头——箭头->把参数列表与Lambda主体分隔开。
Lambda主体——比较两个Apple的重量。表达式就是Lambda的返回值了。

1.4 Lambda的基本语法是：(parameters) -> expression
或（请注意语句的花括号）：(parameters) -> { statements; }

根据上述语法规则，以下哪个不是有效的Lambda表达式？
(1) () -> {}
(2) () -> "Raoul"
(3) () -> {return "Mario";}
(4) (Integer i) -> return "Alan" + i;
(5) (String s) -> {"IronMan";}
答案：只有4和5是无效的Lambda。
(1) 这个Lambda没有参数，并返回void。它类似于主体为空的方法：public void run() {}。
(2) 这个Lambda没有参数，并返回String作为表达式。
(3) 这个Lambda没有参数，并返回String（利用显式返回语句）
(4) return是一个控制流语句。要使此Lambda有效，需要使花括号，如下所示：
(Integer i) -> {return "Alan" + i;}。
(5)“Iron Man”是一个表达式，不是一个语句。要使此Lambda有效，你可以去除花括号
和分号，如下所示：(String s) -> "Iron Man"。或者如果你喜欢，可以使用显式返回语
句，如下所示：(String s)->{return "IronMan";}。

2.在哪里以及如何使用 Lambda

2.1 函数式接口
什么是函数式接口呢？函数式接口就是：只定义一个抽象方法的接口。

2.2javaAPI中包含的一些函数式接口：

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();
}

2.3下面哪些接口是函数式接口？

public interface Adder{int add(int a, int b);
}
public interface SmartAdder extends Adder{int add(double a, double b);
}
public interface Nothing{}
答案：只有Adder是函数式接口。
SmartAdder不是函数式接口，因为它定义了两个叫作add的抽象方法（其中一个是从
Adder那里继承来的）。
Nothing也不是函数式接口，因为它没有声明抽象方法。

2.4用函数式接口可以干什么呢？为什么lambda表达式要使用在函数式接口中呢？
lambda表达式允许你直接以内联的方式为函数式接口中的抽象方法提供实现。并把整个表达式作为函数式接口的的实例。（具体说来，是函数式接口一个具体实现的实例）。你用匿名内部类也可以完成同样的事情，只不过比较笨拙：需要提供一个实现，然后再直接内联将它实例化。下面的代码是有效的，因为Runnable是一个只定义了一个抽象方法run的函数式接口：

Runnable r1 = () -> System.out.println("Hello World 1");   //使用Lambda
Runnable r2 = new Runnable(){                              //使用匿名类public void run(){System.out.println("Hello World 2");}
};
public static void process(Runnable r){                 r.run();
}
process(r1);                                            //打印“Hello World 1”
process(r2);                                            //打印“Hello World 2”
process(() -> System.out.println("Hello World 3"))     //利用直接传递的Lambda打印“Hello World 3

2.5 函数描述符
函数式接口的抽象方法的签名，我们就叫作：函数描述符。
什么是抽象方法的签名？例：抽象方法：int example(Apple a1,Apple a2)。容易看的出：这个抽象方法需要的参数为：Apple a1和Apple a2，然后返回的类型为：int类型。那么这个抽象方法的签名就是：(Apple,Apple) -> int 这样的。代表接受两个Apple作为参数且返回int的函数。
这时候如果我们需要使用lambda表达式来进行参数传入，这lambda表达式的签名要求与函数描述符一致，也就是说：lambda表达式的签名应该也是等于：(Apple,Apple) -> int 这样的。

现在，只要知道Lambda表达式可以被赋给一个变量，或传递给一个接受函数式接口作为参数的方法就好了，当然这个Lambda表达式的签名要和函数式接口的抽象方法一样。
举几个例子：

以下哪些是使用Lambda表达式的有效方式？
(1) execute(() -> {});public void execute(Runnable r){r.run();}
(2) public Callable<String> fetch() {return () -> "Tricky example ;-)";}(3)public interface Predicate<T>{boolean test(T t);
}
Predicate<Apple> p = (Apple a) -> a.getWeight();答案：只有1和2是有效的。
第一个例子有效，是因为Lambda() -> {}具有签名() -> void，这和Runnable中的
抽象方法run的签名相匹配。请注意，此代码运行后什么都不会做，因为Lambda是空的！
第二个例子也是有效的。事实上，fetch方法的返回类型是Callable<String>。
Callable<String>基本上就定义了一个方法，签名是() -> String，其中T被String代替
了。因为Lambda() -> "Trickyexample;-)"的签名是() -> String，所以在这个上下文
中可以使用Lambda。
第三个例子无效，因为Lambda表达式(Apple a) -> a.getWeight()的签名是(Apple) ->
Integer，这和Predicate<Apple>:(Apple) -> boolean中定义的test方法的签名不同。

@FunctionalInterface又是怎么回事？
如果你去看看新的Java API，会发现函数式接口带有@FunctionalInterface的标注（3.4
节中会深入研究函数式接口，并会给出一个长长的列表）。这个标注用于表示该接口会设计成
一个函数式接口。如果你用@FunctionalInterface定义了一个接口，而它却不是函数式接
口的话，编译器将返回一个提示原因的错误。例如，错误消息可能是“Multiple non-overriding
abstract methods found in interface Foo”，表明存在多个抽象方法。请注意，@FunctionalInterface不是必需的，但对于为此设计的接口而言，使用它是比较好的做法。它就像是@Override
标注表示方法被重写了。

3. 把 Lambda 付诸实践：环绕执行模式

资源处理（例如处理文件或数据库）时一个常见的模式就是打开一个资源，做一些处理，
然后关闭资源。这个设置和清理阶段总是很类似，并且会围绕着执行处理的那些重要代码。这就
是所谓的环绕执行（execute around）模式。
比如：

public static String processFile() throws IOException {try (BufferedReader br =new BufferedReader(new FileReader("data.txt"))) {return br.readLine();}
}

图中，任务A和任务B周围都环绕着进行准备/清理的同一段冗余代码。

行为参数化思想：
现在这段代码是有局限的。你只能读文件的第一行。如果你想要返回头两行，甚至是返回使用最频繁的词，该怎么办呢？在理想的情况下，你要重用执行设置和清理的代码，并告诉processFile方法对文件执行不同的操作。这听起来是不是很耳熟？是的，你需要把processFile的行为参数化。你需要一种方法把行为传递给processFile，以便它可以利用BufferedReader执行不同的行为。

第 1 步：记得行为参数化
传递行为正是Lambda的拿手好戏。那要是想一次读两行，这个新的processFile方法看起
来又该是什么样的呢？基本上，你需要一个接收BufferedReader并返回String的Lambda。例
如，下面就是从BufferedReader中打印两行的写法：

String result = processFile((BufferedReader br) -> br.readLine() + br.readLine());

第 2 步：使用函数式接口来传递行为
我们前面解释过了，Lambda仅可用于上下文是函数式接口的情况。你需要创建一个能匹配BufferedReader -> String，还可以抛出IOException异常的接口。让我们把这一接口叫作
BufferedReaderProcessor吧。

@FunctionalInterface
public interface BufferedReaderProcessor {String process(BufferedReader b) throws IOException;
}
//现在你就可以把这个接口作为新的processFile方法的参数了：
public static String processFile(BufferedReaderProcessor p) throwsIOException {…
}

第 3 步：执行一个行为
任何BufferedReader -> String形式的Lambda都可以作为参数来传递，因为它们符合
BufferedReaderProcessor接口中定义的process方法的签名。现在你只需要一种方法在
processFile主体内执行Lambda所代表的代码。请记住，Lambda表达式允许你直接内联，为
函数式接口的抽象方法提供实现，并且将整个表达式作为函数式接口的一个实例。因此，你可
以在processFile主体内，对得到的BufferedReaderProcessor对象调用process方法执行
处理：

public static String processFile(BufferedReaderProcessor p) throwsIOException {try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {return p.process(br);}
}

4 步：传递 Lambda
现在你就可以通过传递不同的Lambda重用processFile方法，并以不同的方式处理文件了。

//处理一行：
String oneLine =processFile((BufferedReader br) -> br.readLine());
//处理两行：
String twoLines =processFile((BufferedReader br) -> br.readLine() + br.readLine());

行为参数化在java8中是一个很重要的编程思想，如何才能不重复制造轮子，更高效率的利用写过的代码，让写的方法更加的灵活和多变。

剩下的内容：

函数式接口，类型推断
方法引用
Lambda复合

都是以上面讲的内容为基础的，很简单的没必要讲了，这里就不说了。