JDK 8 中Lambda表达式的使用

认识Lambda表达式
　　首先来引入一个示例
 new Thread(new Runnable() {
     @Override
     public void run() {
         System.out.println("Hello World!");
         }
     });

　　使用Lambda表达式则只需要使用一句话就可代替上面使用匿名类的方式。
       new Thread(() -> System.out.println("Hello World!"));

　　在这个例子中，传统的语法规则，是将一个匿名内部类作为参数进行传递，实现了Runnable接口，并将其作为参数传递给Thread类，这实际上传递的是一段代码，也即将代码作为了数据进行传递，这就带来许多不必要的“样板代码”。
　　Lambda表达式一共有三部分组成：左边代表参数 -> 右边代表函数主体
　　后面的示例中会详解这个结构，包括有无参数，有无返回值的问题。 那么这个看起来奇奇怪怪的不太像Java的语法规则，其本身含义到底什么呢？这也是开始困扰的问题，什么时候在什么场景下可以使用Lambda表达式。
　　能够接收Lambda表达式的参数类型，是一个只包含一个方法的接口。只包含一个方法的接口称之为“函数接口”。
　　例如上面创建一个线程的示例，Runnable接口只包含一个方法，所以它被称为“函数接口”，所以它可以使用Lambad表达式来代替匿名内部类。根据这个规则，试着来写一个函数接口，并使用Lambda表达式作为参数传递。

package com.coderbuff.custom;
 
 /**
  * 函数接口：只有一个方法的接口。作为Lambda表达式的类型
  */
 public interface FunctionInterface {
     void test();
 }

　　测试：
  package com.coderbuff.custom;
 
  import org.junit.Test;
 
  /**
   * 函数接口测试
   */
  public class FunctionInterfaceTest {
 
     @Test
     public void testLambda() {
         func(new FunctionInterface() {
             @Override
             public void test() {
                 System.out.println("Hello World!");
             }
         });
         //使用Lambda表达式代替上面的匿名内部类
         func(() -> System.out.println("Hello World"));
     }
 
     private void func(FunctionInterface functionInterface) {
         functionInterface.test();
     }
 }

　　可以看到，只要是一个接口中只包含一个方法，则可以使用Lambda表达式，这样的接口称之为“函数接口”。
　　上面的函数接口比较简单不包含参数，也不包含返回值。
　　再来修改FunctionInterface函数接口逐步加大Lambda表达式的难度——包含参数，不包含返回值。

package com.coderbuff.custom;
 
 /**
  * 函数接口：只有一个方法的接口。作为Lambda表达式的类型
  */
 public interface FunctionInterface {
     void test(int param);
 }

　　测试：
  package com.coderbuff.custom;
 
  import org.junit.Test;
 
  /**
   * 函数接口测试
   */
  public class FunctionInterfaceTest {
 
     @Test
     public void testLambda() {
         //使用Lambda表达式代替匿名内部类
         func((x) -> System.out.println("Hello World" + x));
     }
 
     private void func(FunctionInterface functionInterface) {
         int x = 1;
         functionInterface.test(x);
     }
 }

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

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

package com.coderbuff.custom;
 
 /**
  * 函数接口：只有一个方法的接口。作为Lambda表达式的类型
  */
 public interface FunctionInterface<T> {
     void test(T param);
 }　

　　测试：
  package com.coderbuff.custom;
 
  import org.junit.Test;
 
  /**
   * 函数接口测试
   */
  public class FunctionInterfaceTest {
 
     @Test
     public void testLambda() {
         //使用Lambda表达式代替匿名内部类
         func((Integer x) -> System.out.println("Hello World" + x));
     }
 
     private void func(FunctionInterface<Integer> functionInterface) {
         int x = 1;
         functionInterface.test(x);
     }
 }

　　上面的示例提到了Lambda表达式的两种情况：
　　无参数，无返回值；
　　有参数，无返回值。
　　接下来就是有参数，有返回值这种较为复杂的情况。

package com.coderbuff.custom;
 
 /**
  * 函数接口：只有一个方法的接口。作为Lambda表达式的类型
  */
 public interface FunctionInterface<T> {
     boolean test(T param);
 }

　　测试：
  package com.coderbuff.custom;
 
  import org.junit.Test;
 
  /**
   * 函数接口测试
   */
  public class FunctionInterfaceTest {
 
     @Test
     public void testLambda() {
         //使用Lambda表达式代替匿名内部类
         func((Integer x) -> true);
     }
 
     private void func(FunctionInterface<Integer> functionInterface) {
         int x = 1;
         functionInterface.test(x);
     }
 }

　　此时的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通过流的方式则可以望文生义且代码量大大减小。