JDK8的新特性——Lambda表达式

　　JDK8已经发布快4年的时间了，如今来谈它的新特性显得略微的有点“不合时宜”。尽管JDK8已再也不“新”，但它的重要特性之一——Lambda表达式依然是不被大部分开发者所熟练运用，甚至不被开发者所熟知。

　　国内的开发环境你们都知道，有各类的老项目，有各类各样的发布风险，让公司以及项目组对新的技术每每望而却步，有公司甚至时至今日还在使用JDK6来进行项目开发，这致使了在不少技术的选择上受到了很大限制，进而不能跟随时代的脚步使得项目甚至公司一步一步走向衰落。

　　本文简单认识JDK8的重要新特性之一——Lambda表达式。 在JDK8以前，Java是不支持函数式编程的，所谓的函数编程，便可理解是将一个函数（也称为“行为”）做为一个参数进行传递。一般咱们说起得更多的是面向对象编程，面向对象编程是对数据的抽象（各类各样的POJO类），而函数式编程则是对行为的抽象（将行为做为一个参数进行传递）。在JavaScript中这是很常见的一个语法特性，但在Java中将一个函数做为参数传递这却行不通，好在JDK8的出现打破了Java的这一限制。

 

认识Lambda表达式

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

1 new Thread(new Runnable() {
2     @Override
3     public void run() {
4         System.out.println("Hello World!");
5     }
6 });

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

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

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

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

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

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

　　可以接收Lambda表达式的参数类型，是一个只包含一个方法的接口。只包含一个方法的接口称之为“函数接口”。

　　例如上面建立一个线程的示例，Runnable接口只包含一个方法，因此它被称为“函数接口”，因此它可使用Lambad表达式来代替匿名内部类。根据这个规则，咱们试着来写一个函数接口，并使用Lambda表达式做为参数传递。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函数接口：只有一个方法的接口。做为Lambda表达式的类型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface {
8     void test();
9 }

 　　测试：

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函数接口测试
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         func(new FunctionInterface() {
14             @Override
15             public void test() {
16                 System.out.println("Hello World!");
17             }
18         });
19         //使用Lambda表达式代替上面的匿名内部类
20         func(() -> System.out.println("Hello World"));
21     }
22 
23     private void func(FunctionInterface functionInterface) {
24         functionInterface.test();
25     }
26 }

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

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

　　咱们再来修改FunctionInterface函数接口逐步加大Lambda表达式的难度——包含参数，不包含返回值。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函数接口：只有一个方法的接口。做为Lambda表达式的类型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface {
8     void test(int param);
9 }

　　测试：

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函数接口测试
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表达式代替匿名内部类
14         func((x) -> System.out.println("Hello World" + x));
15     }
16 
17     private void func(FunctionInterface functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

　　关注Lambda表达式“(x) -> Sysout.out.println("Hello World" + x)”，左边传递的是参数，此处并无指明参数类型，由于它能够经过上下文进行类型推导，但在有些状况下不能推导出参数类型（在编译时不能推导一般IDE会提示），此时则须要指明参数类型。我我的建议，任何状况下指明函数的参数类型。

　　哪一种状况不能推导出参数类型呢？就是函数接口是一个泛型的时候。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函数接口：只有一个方法的接口。做为Lambda表达式的类型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface<T> {
8     void test(T param);
9 }　

　　测试：

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函数接口测试
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表达式代替匿名内部类
14         func((Integer x) -> System.out.println("Hello World" + x));
15     }
16 
17     private void func(FunctionInterface<Integer> functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

　　上面的示例提到了Lambda表达式的两种状况：

　　无参数，无返回值；

　　有参数，无返回值。

　　接下来就是有参数，有返回值这种较为复杂的状况。

1 package com.coderbuff.custom;
2 
3 /**
4  * 函数接口：只有一个方法的接口。做为Lambda表达式的类型
5  * Created by Kevin on 2018/2/17.
6  */
7 public interface FunctionInterface<T> {
8     boolean test(T param);
9 }

 　　测试：

 1 package com.coderbuff.custom;
 2 
 3 import org.junit.Test;
 4 
 5 /**
 6  * 函数接口测试
 7  * Created by Kevin on 2018/2/17.
 8  */
 9 public class FunctionInterfaceTest {
10 
11     @Test
12     public void testLambda() {
13         //使用Lambda表达式代替匿名内部类
14         func((Integer x) -> true);
15     }
16 
17     private void func(FunctionInterface<Integer> functionInterface) {
18         int x = 1;
19         functionInterface.test(x);
20     }
21 }

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

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

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

　　无参数，无返回值；

　　有参数，无返回值；

　　有参数，有返回值。

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

 

JDK8使用集合的正确姿式

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

　　在JDK8前的代码：

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

　　JDK8使用集合的正确姿式：

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

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

　　其中最为重要的是——Stream流。Stream的是经过函数式编程方式实现的在集合类上进行复杂操做的工具。若要详细讲解Stream的实现方式我相信再写一篇博客也不为过，因此此处再也不考查Stream的内部实现。这里是想告诉你们，若是有幸使用JDK8的开发环境进行开发，尽可能学习使用新的集合操做API。

　　上面对于Lambda表达式以及函数式编程仅仅只是到了一个“认识”的地步，彷佛只是感觉到了缩小代码量，本文对于Lambda式的认识不深刻更多的是对于后面更多的知识作一个铺垫或者做为一个扫盲贴，有关Lambda表达式的应用太多，并发编程、响应式编程等等。若是你有关于Lambda表达式或者函数式编程有更好的看法不妨留下评论。

 

 

这是一个能给程序员加buff的公众号