JDK8_01_JDK8新特性，Lambda表达式带来函数式编程，简化代码

一、前言

函数编程：将一个函数（也称为“行为”）作为一个参数进行传递。

面向对象编程：对数据的抽象（各种各样的POJO类）；
函数式编程：对行为的抽象（将行为作为一个参数进行传递）。

函数式编程在JavaScript中这是很常见的一个语法特性，但是，在JDK8之前，Java中将一个函数作为参数传递这却行不通，好在JDK8的出现打破了Java的这一限制，方案就是Lambda表达式。

二、初识Lambda表达式

2.1 Lambda表达式的使用

先看一个示例，不知给是否有在IDEA编写代码的经历，如果在JDK8的环境下如下所示按照Java传统的语法规则编写一个线程。

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World!");
    }
});

IDEA会给出提示可以使用Lambda表达式替换。

使用Lambda表达式则只需要使用一句话就可代替上面使用匿名类的方式。

new Thread(() -> System.out.println("Hello World!"));

在这个例子中，传统的语法规则，我们是将一个匿名内部类作为参数进行传递，我们实现了Runnable接口，并将其作为参数传递给Thread类，这实际上我们传递的是一段代码，也即我们将代码作为了数据进行传递，这就带来许多不必要的“样板代码”。

2.2 Lambda表达式的结构

Lambda表达式一共有三部分组成：

后面的示例中我们会详解这个结构，包括有无参数，有无返回值的问题。 那么这个看起来奇奇怪怪的不太像Java的语法规则，其本身含义到底什么呢？这也是开始困扰我的问题，什么时候在什么场景下可以使用Lambda表达式。

三、三种情况修改为Lambda表达式

3.1 函数接口不包含参数，不包含返回值

Lambda表达式三部分，参数列表 + -> + 方法体，能够将匿名内部类写成Lambda表达式的参数类型，是一个只包含一个方法的接口。只包含一个方法的接口称之为“函数接口”。Lambda表达式实际就是函数式接口的实现，和之前的匿名内部类实现接口是一样的，就是将 实参 传递为参数列表，重写抽象方法。

例如创建一个线程，Runnable接口只包含一个方法，所以它被称为“函数接口”，所以它可以使用Lambda表达式来代替匿名内部类。根据这个规则，我们试着来写一个函数接口，并使用Lambda表达式作为参数传递。

主代码：

public class Main {
    public static void main(String[] args) {
        func(new FunctionInterface() {
            @Override
            public void test() {
                System.out.println("Hello World!");
            }
        });
        //使用Lambda表达式代替上面的匿名内部类
        func(() -> System.out.println("Hello World"));
    }

    private static void func(FunctionInterface functionInterface) {
        functionInterface.test();
    }
}


interface FunctionInterface {
    void test();
}

输出结果：

Hello World!
Hello World

可以看到，只要是一个接口中只包含一个方法，则可以使用Lambda表达式，这样的接口称之为“函数接口”。

上面的函数接口比较简单不包含参数，也不包含返回值。

3.2 函数接口包含参数，不包含返回值

3.2.1 函数接口包含参数，不包含返回值

主代码：

public class Main {
    public static void main(String[] args) {
        func((x) -> System.out.println("Hello World" + x));
    }

    private static void func(FunctionInterface functionInterface) {
        int x = 1;
        functionInterface.test(x);
    }
}

interface FunctionInterface {
    void test(int param);
}

输出结果：

Hello World1

关注Lambda表达式“(x) -> Sysout.out.println(“Hello World” + x)”，左边传递的是参数，此处并没有指明参数类型，因为它可以通过上下文进行类型推导，但在有些情况下不能推导出参数类型（在编译时不能推导通常IDE会提示），此时则需要指明参数类型。我个人建议，任何情况下指明函数的参数类型。

3.2.2 函数接口包含参数，不包含返回值（泛型接口）

就是函数接口是一个泛型的时候，不能推导出参数类型。

主代码：

public class Main {
    public static void main(String[] args) {
        //使用Lambda表达式代替匿名内部类
        func((Integer x) -> System.out.println("Hello World" + x));
    }

    private static void func(FunctionInterface<Integer> functionInterface) {
        int x = 1;
        functionInterface.test(x);
    }
}

interface FunctionInterface<T> {
    void test(T param);
}

输出结果：

Hello World1

3.3 函数接口包含参数，包含返回值

代码：

public class Main {
    public static void main(String[] args) {
        //使用Lambda表达式代替匿名内部类
        func((Integer x) -> true);
    }

    private static void func(FunctionInterface<Integer> functionInterface) {
        int x = 1;
        functionInterface.test(x);
    }
}

interface FunctionInterface<T> {
    boolean test(T param);
}

输出结果：

此时的Lambda表达式“(Integer x) -> true”，右边是表达式的主体，直接返回true，如果有多行代码，则可以直接使用花括号表示，例如：

func((Integer x) -> {
    System.out.println("Hello World" + x);
    return true;
});

代码：

public class Main {
    public static void main(String[] args) {
        //使用Lambda表达式代替匿名内部类
        // 方法体有多行，用大括号
        func((Integer x) -> {
            System.out.println("Hello World" + x);
            return true;
        });
    }

    private static void func(FunctionInterface<Integer> functionInterface) {
        int x = 1;
        functionInterface.test(x);
    }
}

interface FunctionInterface<T> {
    boolean test(T param);
}

输出结果：

Hello World1

Lambda表达式基本的语法规则：

无参数，无返回值；

有参数，无返回值；

有参数，有返回值。

这三种基本情况已经大致清楚了，特别是需要弄清，什么时候可以使用Lambda表达式代替匿名内部类，也就是Lambda表达式的应用场景是函数接口。Lambda表达式这一新特性在JDK8中的引入，更大的好处则是集合API的更新，新增的Stream类库，使得我们在遍历使用集合时不再像以往那样不断地使用for循环。

四、JDK8使用集合的正确姿势

示例：计算来自“chengdu”的学生数量有多少。

在JDK8前的代码，即foreach循环：

for (Student student : studentList) {
    if (student.getCity().equals("chengdu")) {
        count++;
    }
}

JDK8使用集合的正确姿势，stream流模式就是对foreach循环的简化：

count = studentList.stream().filter((student -> student.getCity().equals("chengdu"))).count();

集合对象.stream().工具方法名(实参).工具函数(实参)

jdk8中，.stream得到的java.util.stream.Stream对象取代foreach迭代，并提供一系列的工具函数实现基本的数据聚合操作，类型 sql 语言里面的 聚合函数。

stream类的 多个工具函数，返回值都是Stream，所以可以不断的调用工具方法，有责任链模式的影子。

API的使用“难度”恰似提高了，实际只是不熟悉而已。传统迭代的方式需要阅读完整个循环才能明白代码逻辑，JDK8通过流的方式则可以望文生义且代码量大大减小。

其中最为重要的是——Stream流。Stream的是通过函数式编程方式实现的在集合类上进行复杂操作的工具。

五、尾声

本文对于Lambda表达式以及函数式编程仅仅只是到了一个“认识”的地步，似乎只是感受到了缩小代码量，本文对于Lambda式的认识不深入更多的是对于后面更多的知识做一个铺垫或者作为一个扫盲贴，有关Lambda表达式的应用太多，并发编程、响应式编程等等。

jdk8的新特性：lambda表达式、stream流模式、hashmap底层二叉树的优化、LocalDateTime+LocalDate+LocalTime 处理时间。

天天打码，天天进步！！