Java语言十五讲(第十讲 Lambda 表达式)

我们要从匿名类开始讲起，一点点引出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（简洁是智慧的灵魂）。