我们要从匿名类开始讲起，一点点引出Lambda表达式。我比较喜欢Lambda这个词，显得比较有学问似的，一笑。
我讲过，技术点不是孤立的，它们之间是有关联的，按照某种层次结构关联在一起就构成一个体系。我们在学习某个技术的时候，要了解它的来龙去脉，把某个技术点放在整体中学习会更有收获。事实上，学术论文一般都要求开头一段讲学术史，这是有道理的。当然，有个别天才能在不引用任何参考文献的情况下提出划时代的理论，横空出世。最著名的就是爱因斯坦在1905年写的《论动体的电动力学》。
以前提到过Inner Class内部类中有一种是可以不用起名字的，称之为匿名类。使用匿名类是因为我们有些场景中不需要知道名字，也不关心它的名字，而是关心它里面的方法，这在事件响应模型中会常用。
先看一个例子吧，先用普通写法，代码如下：
interface Adder {
int add(int x, int y);
}
class MyAdder implements Adder {
@Override
public int add(int x, int y) {
return (x+y);
}
}
class AdderDemo {
public static void main(String[] args) {
MyAdder adder = new MyAdder();
System.out.println(adder.add(21,37));
}
}
程序简单，定义了一个interface，一个MyAdder class实现它，用AdderDemo测试。运行无误。我们看，其实概念上可以不显示声明一个MyAdder类的，我们可以在使用的时候直接弄一个，这样程序更加简洁。
看下面这个匿名类版本，代码如下：
interface Adder {
int add(int x, int y);
}
class AdderDemo {
public static void main(String[] args) {
Adder adder = new Adder() {
@Override
public int add(int x, int y) {
return (x+y);
}
};
System.out.println(adder.add(21,37));
}
}
这次，我们没有显示声明一个MyAdder类，而是在使用的时候临时创建了一个对象，而这个对象依赖的类是没有名字的，临时定义的。这种写法比原始版本要简洁了。
我们再仔细看这个接口，它就只有一个add方法，我们用这个接口其实是想用这个方法。这种情况，我们叫它functional interface函数式接口。有一种更加简洁的写法，见下面的代码(Test1.java)：
public class Test1 {
public static void main(String[] argv) {
engine((int x, int y)-> {return x + y;});
engine((x, y)-> {return x + y;});
engine((x,y)-> x + y);
}
private static void engine(Calculator calculator){
int x = 4, y = 2;
int result = calculator.calculate(x,y);
System.out.println(result);
}
}
@FunctionalInterface
interface Calculator{
int calculate(int x, int y);
}
上面的代码中，我们定义了一个Calculator接口，里面就一个calculate方法，这是典型的函数式接口。使用的程序中，我们提供一个engine方法，它以Calculator为参数，调用接口中的calculate方法。
再看对engine方法的调用，仔细看一看，现在不是生成一个匿名类的写法了，而是写成了(int x, int y)-> {return x + y;}，比较一下匿名类里面的写法，似乎就是把方法体拷贝过来了，省略了接口名和方法名。概念上这么理解是对的。这里就用到了Lambda表达式，只显示定义参数和方法体。实际上还可以进一步简化成engine((x, y)-> {return x + y;});以及engine((x,y)-> x + y);。
这种写法是把实现方法的函数体当成参数使用了，跟传一个普通变量一样。我们要把上面的程序略加增强就能更加清晰地看出来了，把上面main()中的engine((x,y)-> x + y);扩充成四个语句：
engine((x,y)-> x + y);
engine((x,y)-> x - y);
engine((x,y)-> x * y);
engine((x,y)-> x / y);
你们运行一下看结果。我们把+-/操作当成了方法参数传进去并运行。所以这种机制的作用是干这个，并不只是简单的简化代码的编写。有一个术语叫“code as data”就是说的这件事情。 Lambda表达式就是让你能够实现上面的code as data机制而规定的一种写法。Lambda 表达式给Java中引入了操作符-> ，表达式分成两部分： (n) -> nn
左边的就是表达式的参数，如果没有参数，就用一个空括号。右边的就是操作语句，操作语句不仅仅只有一个数学表达式，它可以是任意的程序语句。如：
RevString revStr = (str) -> {
String result = "";
for(int i = str.length()-1; i >= 0; i--)
result += str.charAt(i);
return result;
};
Lambda表达式不是Java的发明，实际上大家千呼万唤，才姗姗来迟纳入到Java8中。自然，延迟主要的原因是因为Java命运坎坷，被Oracle收购，中间折腾了好几年，早就计划好的事情迟迟不能实现。
Lambda表达式是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，即没有函数名的函数。在数学和工程领域使用的比较多，是科技工作者的心头好，最主要的是简洁显得有geek范。在别的许多语言中，早就支持了Lambda表达式，如C#和Javascript。
函数式语言提供了一种强大的功能：闭包。闭包是一个可调用的对象，它使用和处理一些信息，这些信息来自于创建它的作用域。Java 现在提供的最接近闭包的概念便是 Lambda 表达式。Java里面没有独立函数，因此，为了实现函数式编程，就用了函数式接口进行包装，一个有且仅有一个方法的接口。通过这种退化的方式模拟独立函数。有人却嘲讽Java是以名词为中心的，也确实是这样的，其实所有面向对象的语言都是以名词为中心的，RESTful风格的接口也是名词为中心的。从技术哲学角度，这个好不好，见仁见智，我个人觉得要以名词为中心辅助以动词。Java里面名词中心主义色彩确实太重了，正如这个物理世界，除了实体，还有实体之间的相互作用就是力，Java里面缺乏这个。AOP的思想有一点这个意思，能够穿透实体，加上装饰（Docoration/Advice），统一做某些事情。但是这是架构层面实现的，语言本身的层面没有提出来。比较起人类自己用的科学语言来，计算机语言还有很大的不足。虽然我们现在没有办法用一个方程描述世界，但是几大支柱概念都已经建立起来了，particle粒子，filed场，force力，dimension维度，symmetry对称性。
再看一个在list中使用Lambda表达式的例子，代码如下(Test.java)：
public class Test{
public static void main(String[] argv) {
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(1);
al.add(2);
al.add(3);
al.forEach(n -> System.out.println(n));
}
}
上面代码对arraylist中的每一个元素，执行打印动作。
如果我们的好奇心再强一点，看看编译之后的结果，Java究竟怎么处理的上面的Lambda表达式，我们可以试着反编译一下看结果，我们会看到编译器自动生成了一个私有方法，然后使用Lambda表达式的地方都会改成动态调用这个私有方法，形如：
private static void Test$main$0(Integer n) {
System.out.println(n);
}
你们可以自己试一下，不过不同的编译器结果可能会有不同。
把Lambda表达式当成方法引用的时候，还可以进一步用::双冒号简化代码：
al.forEach(System.out::println);
jdk8中使用了::的用法。就是把方法当做参数，每个元素都传入到该方法里面执行一下。代码进一步简化，生人也更难理解了。科技就是这样，符号用得越多越怪就越有学问。
Lambda表达式有一个限制，它不能是Generic泛型的。但是我们结合一下泛型接口有可以实现不同类型的操作。举一个例子，代码如下(Test2.java)：
public class Test2 {
public static void main(String[] argv) {
Adder adder = (int x, int y)-> {return x + y;};
System.out.println(adder.add(12,34));
}
}
@FunctionalInterface
interface Adder{
int add(int x, int y);
}
这个例子中用到了一个add方法，是用于把两个整型相加的。如果我们想把两个字符串相加就做不到了，Lambda表达式不支持泛型。我们来看怎么用泛型改造上面的代码：
public class Test2 {
public static void main(String[] argv) {
Adder<Integer> adder = (Integer x, Integer y)-> {return x + y;};
System.out.println(adder.add(12,34));
Adder<String> adder2 = (String x, String y)-> {return x.concat(y);};
System.out.println(adder2.add("12","34"));
}
}
@FunctionalInterface
interface Adder<T>{
T add(T x, T y);
}
先把接口改成泛型，再在用Lambda表达式的时候指定不同类型。两者结合在一起就可以了。
Lambda 表达式改进了Collection库，更容易遍历，过滤。比如Comparator类是用来给list排序的，以前这么写：
Collections.sort(studentList, new Comparator<Student>(){
public int compare(Student p1, Student p2){
return p1.getName().compareTo(p2.getName());
}
});
用Lambda表达式这么写，简化不少：
Collections.sort(studentList, (Student p1, Student p2) -> p1.getName().compareTo(p2.getName()));
数据过滤也是，我们现在能把数据集进行一系列处理了。看一个例子。
先定义一个Student类，代码如下(Student.java)：
public class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
}
再写一个使用的类，是Student列表，进行过滤排序等操作。代码如下(StudentTest.java)：
public class StudentTest {
public static void main(String args[]) {
Student s1 = new Student("Alice", 87);
Student s2 = new Student("Bob", 57);
Student s3 = new Student("Chris", 102);
Student s4 = new Student("Donald", 110);
Student s5 = new Student("Cohn", 108);
List<Student> students = Arrays.asList(s1, s2, s3, s4, s5);
students.stream()
.filter(s -> s.getScore() > 100)
.sorted((p1, p2) -> p1.getName().compareTo(p2.getName()))
.collect(Collectors.toList())
.forEach(System.out::println);
}
}
上面的核心代码就是最后一句，我们用了一个Stream流水式写法，将列表先过滤再排序最后打印，通过.符号一步步流水执行。代码非常简洁，难怪成为数学家工程师们的最爱。
filter里面，我们用的Lambda表达式是s -> s.getScore() > 100，过滤分数超过100的数据。这是简单表达式，也可以用复杂点的，如s -> s.getScore() > 100 && s.getName().startsWith("C")，过滤分数超过100并且名字以C开头的数据。
sorted里面，我们用的Lambda表达式是(p1, p2) -> p1.getName().compareTo(p2.getName())，用getName拿到的名字字符串进行比较排序，因为String类里面提供了compareTo方法，我们直接使用。要是不指定这个表达式，写成sorted()会有什么效果？我们试一下，编译是不会出错的，但是运行结果有错(如果数据为空或者只有一条数据不会出错，因为这种情况下其实没有进行比较排序)：
java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable
at java.util.Comparators$NaturalOrderComparator.compare(Unknown Source)
原因是sorted没有参数，系统拿着这个student不知道该怎么比较，这个时候，我们可以实现Comparable提供一个compareTo方法就可以了:
public int compareTo(Student s2) {
return this.getName().compareTo(s2.getName());
}
说到重写，要再提一句，上面最后执行System.out::println的时候，或许出现的是类似这个结果：
Student@7ba4f24f
Student@3b9a45b3
Student@7699a589
那是因为println其实是调用的对象的toString()方法，我们没有自己给Student提供这个方法，就出这么一个结果，自己提供一个就可以了。综合上面的考虑，最后Student类代码变成这个样子，代码如下(Student.java)：
public class Student implements Comparable<Student>{
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public int getScore() {
return score;
}
public String toString() {
return name + " " + score;
}
public int compareTo(Student s2) {
return this.getName().compareTo(s2.getName());
}
}
上面看了过滤和排序，还可以把list里面的数据做一个平方转换，示例如下：
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
for(Integer n : list) {
int x = n * n;
System.out.println(x);
}
现在用Lambda表达式，简写成这样：
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
list.stream().map((x) -> x*x).forEach(System.out::println);
以上就是Lambda的基本内容。大家自己多练习。
我们说过，用函数式编程，我们可以把函数本身当成参数，也就可以有返回函数的函数，我们把这种叫高阶函数，还可以用一种级联式写法串在一起。
看一段代码：
public stat int filterSum(List<Integer> values, Predicate<Integer> filter) {
return values.stream()
.filter(filter)
.reduce(0, Integer::sum);
}
这个函数filterSum接收另一个函数filter作为参数，并执行两部操作，一是执行filter，然后执行sum。如果是要求选择所有偶数，就这么用：filterSum(numbers, e -> e % 2 == 0);
函数可以接收函数、lambda 表达式或方法引用作为参数。同样地，函数也可以返回 lambda 表达式或方法引用。在此情况下，返回类型将是函数接口。
再看一段代码：
public static Predicate<Integer> isOdd() {
Predicate<Integer> result = (Integer n) -> n% 2 != 0;
return result ;
}
还可以更加简洁：return n-> n% 2 != 0;
这是返回一个判断数是否为奇数的函数。使用的时候这么用：
Predicate<Integer> check = isOdd();
check.test(4);
我们接着往下面看，怎么真的通过级联的方式把一个Lambda表达式写成一个函数调用。我们的例子就是筛选出被2整除，被3整除，被4整除，被5整除的数据。
自然我们可以这么写：
List<Integer> divide2 = nlist.stream().filter(n % 2 == 0).collect(toList());
List<Integer> divide3 = nlist.stream().filter(n % 3 == 0).collect(toList());
List<Integer> divide4 = nlist.stream().filter(n % 4 == 0).collect(toList());
List<Integer> divide5 = nlist.stream().filter(n % 5 == 0).collect(toList());
我们用了四个Lambda表达式，只是参数略有不同。我们知道内部其实是四个私有方法，我们不想这样，想用一个。
我们做一个函数：
Function<Integer, Predicate<Integer>> divide = (Integer d) -> {
Predicate<Integer> dividen = (Integer n) -> {
return n % d == 0;
};
return dividen;
};
如上，我们定义了一个叫divide的函数，参数是d，即除数(2,3,4,5)。内部是又定义了一个dividen，这个dividen就是一个Lambda表达式判断是否能整除。这里就涉及到两层级联。
整体代码如下(Test4.java)：
public class Test4 {
public static void main(String[] argv) {
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(2);
al.add(3);
al.add(4);
al.add(5);
al.add(6);
al.add(7);
Function<Integer, Predicate<Integer>> divide = (Integer d) -> {
Predicate<Integer> dividen = (Integer n) -> {
return n % d == 0;
};
return dividen;
};
List<Integer> values = al.stream().filter(divide.apply(3)).collect(Collectors.toList());
values.forEach(System.out::println);
}
}
运行结果是把被3整除的数据打印出来了。
我们招收简化divide定义。明显的是参数的类型不需要重复写了，然后是内部的dividen其实是不需要显示定义的。这样简化成了：
Function<Integer, Predicate<Integer>> divide = (d) -> {
return (n) -> {
return n % d == 0;
};
};
上面代码还可以简化，你看最里面这个return只有一行，所以可以省掉return。变成：
Function<Integer, Predicate<Integer>> divide = (d) -> {
return (n) -> n % d == 0;
};
留下的这个Lambda表达式还是只有一行，所以再次简化成级联表示：
Function<Integer, Predicate<Integer>> divide = d -> n -> n % d == 0;
上面我们演示了怎么一步一步简化，洋葱一层层耐心地剥，代码一点点简化，头脑越来越明朗。自然，用到的不熟悉的写法和符号也会越来越多，刚才说过这样越来越显得有学问。虽然这么说是开玩笑，但是也不是完全无理。我们看看数学物理的发展史，不断引入新的符号演算，越来越看不懂。为什么会是这样？是为了显得高深而故弄玄虚吗？是科学家为了保饭碗故意这样吗？肯定不是这样。我个人的观点是这是抽象带来的必然结果。人类认识的进程是越来越抽象，不是为了玄虚，而是为了普适，用一条或者几条简单的规则来描述世界。最开头，人是没有抽象能力的，见到的东西都是不同的具体的，后来抽象出类别来，动的东西，不动的东西，固体液体气体，开始对各种相互作用也是分开描述，后来抽象出力这个概念，后来统一成几种力，天上地下一起描述。每一次抽象都会带来新的术语与算符，初看起来就越来越难以弄懂了，其实都是为了简化问题。我们学技术的人，要顺着这个路子往前走，做的程序不光是应对眼前的具体场景，要有普适性，通过抽象来简化问题。
Shakespeare莎士比亚在《Hamlet》写到：Brevity is the soul of wit（简洁是智慧的灵魂）。
