Lambda表达式 函数式编程 Stream API学习笔记

什么是Lambda表达式

我们知道接口是无法直接被实例化的，你只能new他的实现类，但是假如当前接口只有一个抽象方法，又不想再创建一个类，在JDK8之前，你就只能使用匿名内部类。像下面这样:

   new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        }).start();

现在的IDE已经很强大了，你只用写到new Runnable()就会帮你把代码补全，但是你还是要移动光标到run方法体内，写对应的代码。在学到匿名内部类的时候，我就希望代码变的简洁紧凑一些 (事实上官方写的指导书《The Java™ Tutorials》也是将Lambda式放在匿名类这一章下面的，介绍Lambda表达式这一章在: https://docs.oracle.com/javas... )。
JDK8之后上面的代码就可以化简成下面这样:

 new Thread(()-> System.out.println("hello world")).start();

怎么样是不是变得相当简洁了呢! ()-> System.out.println("hello world") 就可以称之为Lambda表达式。Lambda是λ这个符号的名称。
维基百科是这样描述Lambda表达式的:

a function (or a subroutine) defined, and possibly called, without being bound to an identifier。

直接翻译的话就是: 可能被调用的一个函数或者是子程序，但是没有绑定到一个标识符上。

我们放到java里来理解一下，众所周知java是面向对象的，函数也是放在一个类中的。调用方法的话就大致有以下两种形式:

• 类名.方法名
• 类的实例.方法名。

所以在java中，我们姑且就可以将类名+方法名称之为一个标识符，因为我们通过类名(严谨的说是全类名)+方法名定位到一个方法。()-> System.out.println("hello world")，就是一个匿名类和匿名方法的组合化简之后产物，类名没有直接给出，方法名也是没有，这些通通是编译器来给。

百度百科是这样描述Lambda表达式的:

Lambda 表达式（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。--《百度百科》

我们知道数学中的演算是需要运算符(演算符的)，调用一个函数是需要给定参数的，是需要方法体的。

() 里面就可以放参数，-> 是运算符，-> 之后就是方法体。形如()->{}的表达式,在java中我们就可以称之为Lambda表达式。
因为Runnable接口中的run方法没有参数，所以()里面啥也没写。

顺便提一下，Lambda表达式并不算是java率先提出。2007年11月19，.NET Framework 3.5就已经引入了，jdk8的发布时间是2014-03-18。主流的编程语言应该都有这个概念。

我们来想想为什么可以化简到这种地步，假如我们有这样两个方法:

• add(int i)
• add(Long i)

我们称之为方法重载，同一个方法名，参数类型不同。我们在调用的时候,编译器或者说是JVM，就能根据我们给定的参数来调用对应的方法。那么new Thread(()-> System.out.println("hello world"))来推断这是Thread的哪一个构造函数也是能够做到的事情。所以看似你写的是这个：

 new Thread(()-> System.out.println("hello world")).start();

事实上编译器会帮你补成:

   new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        }).start();

这也是一些人说在某些情况下Lambda性能不佳的原因。

适用场景

如果你打开Runnable接口看的话，会发现Runnable接口上有一个注解: @FunctionalInterface。FunctionalInterface意味函数式接口，什么是函数式接口呢？ 就是一个接口中只有一个抽象方法的接口，我们称之为函数式接口。我们知道，jdk8之前接口中只能放抽象方法，jdk8之后可以放非抽象方法。方法中要加上default关键字，我们称之为默认实现。形式如下:

@FunctionalInterface
public interface MyLambdaInterface {
    void sayHello(String str);
    default void sayWorld(String str){
        System.out.println(str);
    }
}

加上@FunctionalInterface的接口,只能有一个抽象方法，允许存在和Object中方法名相同的方法，但要求参数类型一致。否则会通不过编译。如下所示:

@FunctionalInterface
public interface MyLambdaInterface {
    void sayHello(String str);
    int hashCode();
    boolean equals(Object obj);
    default void sayWorld(String str){
        System.out.println(str);
    }
}

Lambda表达式的适用场景即为: 假如我有一个函数式接口，但是呢，我又不想创建这个类的显示实现类(显示实现类即为新建Class文件)，我又想使用这个方法，Lambda表达式大显身手的就到了。

如何使用以及 Lambda表达式的几种形式

我们首先介绍Lambda表达式的形式，在根据形式去讲解如何使用。

• 方法参数

Lambda从形式上来看更像是一个函数,(函数所需要的参数)->{方法实现}

方法参数的话 new Thread(()-> System.out.println("hello world")).start(); 这个就是一个例子。虽然原则上讲并不应该直接创建一个线程，应该通过线程池。
我们知道函数的参数类型可以是基本类型和引用类型，new Thread(()-> System.out.println("hello world")) 这个例子好像就是将一个方法作为参数传递进去了一样。

• 方法引用的形式一: 指向自己创建的方法

以MyLambdaInterface为例，方法引用我们可以这么写:

MyLambdaInterface myLambdaInterface = (str)-> System.out.println(str);

从形式上来讲，myLambdaInterface好像指向一个函数一样。
(str)-> System.out.println(str);就是方法sayHello的实现。

• 方法引用的形式二: 指向已存在的方法

指向已存在的方法的语法为:

• Reference to a static method(引用一个静态方法):

public class Person {
    LocalDate birthday;
    public static int compareByAge(Person a, Person b) {
        return a.birthday.compareTo(b.birthday);
    }
}

方法引用的写法: Person::compareByAge

但是这句话直接出现在代码中会报错，我们需要找一个函数式接口来指向它。函数式接口中的方法返回类型和接收参数要和compareByAge保持一致，像下面这样。

public interface CompareTo<T> {
    int compare(T t1,T t2);
}

  CompareTo<Person> p = Person::compareByAge;

• Reference to an instance method of an arbitrary object of a particular type(对特定类型的实例方法的调用)

  String[] stringArray = {"Barbara", "James", "Mary", "John",
                "Patricia", "Robert", "Michael", "Linda"};
        Arrays.sort(stringArray, String::compareToIgnoreCase);

• Reference to an instance method of a particular object (对特定对象的实例方法的调用)
  首先你需要new一个对象, 形式就是 函数式接口 = 对象::方法
  或者将 对象::方法当做一个方法参数传递进去。
• Reference to a constructor (引用构造函数)

形式: 类名:: new。用法和前面三种是一致的，可以当做一个函数式接口的实现，也可以当做一个方法参数。

Lambda表达式本质上也是内部类，那么同内部类一样，要想要访问局部变量，那么这个局部变量一定要是final类型的。
现在我们来总结一下Lambda表达式的写法:

形式大致是这样: (函数式接口所需的参数)->方法体;

假如方法体只有一行，可以不用写{
例如:

   new Thread(()-> System.out.println()).start();

假如有多行的话需要写{

我们可以认为每一个Lambda表达式都是一个函数式接口的匿名实现。

JDK提供的函数式接口

JDK也内置了一些函数式接口，这些函数式接口大多都在java.util.function下,理解这些函数式接口是学习Stream API的关键。这里我们选取几个比较经典的讲解一下。

• Predicate 断言中抽象方法为: boolean test(T t);
• Consumer 消费，抽象方法为: void accept(T t);
• Function<T, R> 函数式，抽象方法为: R apply(T t);‘
• Supplier<T> 供给型，抽象方法为: T get();

boolean test(T t); 这个方法接收一个参数，返回一个boolean类型的值。

我们可以这样写:

 Predicate<String> predicate = (str)-> str.contains("s");

还可以这样写:

  List<String> list = new ArrayList<>();
  Predicate<String> predicate = list::add;
  predicate.test("add");//等价于调用list.add("add")
  predicate.test("bb");
 

Consumer、 Function、 Supplier用法类似，这里不再做过多的介绍。

由函数式编程到 Stream API

首先Stream是一个接口,位于java.util.stream下。 假如我们的集合泛型是一个学生类，像下面这样。

 List<Student> student = new ArrayList<>();

那么假如我像统计年龄在18岁以上的学生总数，那么在不用流的情况下，我们通常是这样做的。

   int count = 0;
    List<Student> studentList = new ArrayList<>();
    for (Student student : studentList) {
        if (student.getAge() > 18){
            count++;
        }
    }
    

Student可以映射进数据库中,我们在数据库做这样的事情是简单的，那么在代码能否像sql一样执行count,where操作呢。
有了流之后就可以，我们可以这样写:

 studentStream.filter( (student) -> student.getAge() > 18).count();

是不是变的简单多了呢! 那我能不能group by 在count呢，也是可以的。按性别分组求出男生和女生的人数。

 Map<Boolean, Long> result = studentStream.collect(Collectors.groupingBy(Student::isSex, counting()));

细究他的实现的话，这个并不是本篇的主题，本篇只是简单入门，详细讨论是另一篇了。
顺便提一下， 流有两种类型，串行和并行流，这将是我们下一篇文章重点阐释的内容。

总结一下

• Lambda表达式使得代码更为紧凑，使得可以将方法作为参数进行传递。
• 由Lambda方法进一步到Stream，我们就可以将一些数据库的操作,比如where，group by，移植进入代码中，而且更为简洁。

参考资料: The Java™ Tutorials