Java8是自java5之后最重大的一次更新，它给JAVA语言带来了很多新的特性（包括编译器、类库、工具类、JVM等），其中最重要的升级是它给我们带来了Lambda表达式和Stream API。

1、什么是Lambda表达式？

　　Lambda是一个匿名函数，可以理解为是一段可以传递的代码，可以将代码像传递参数、传递数据一样进行传输。使用Lambda表达式，可以写出更加紧凑、更加简洁、更加灵活的代码。

2、使用Lambda的限制条件

　　Lambda并不是任何地方都可以使用，Lambda表达式需要“函数式接口”的支持。

3、什么是函数式接口？

　　接口中只有一个抽象方法的接口，称为函数式接口，可以用@FunctionalInterface修饰一下，这里需要注意的是：未使用 @FunctionalInterfaces注解的接口未必就不是函数式接口，一个接口是不是函数式接口的条件只有一条，即接口中只有一个抽象方法的接口（Object类中的方法不算）。而使用@FunctionalInterface注解修饰了的接口就一定是函数式接口，添加@FunctionalInterface注解可以帮助我们检查是否是函数式接口。

JDK中常见的函数式接口有：

1 @FunctionalInterface2 public interface Runnable {3     void run();4 }

1 @FunctionalInterface2 public interface Callable
     
       {3     V call() throws Exception;4 }
     

以下接口中虽然有两个方法，但因hashCode()是Object类中的方法，因此该接口也是函数式接口：

1 @FunctionalInterface2 public interface FuncInterface {3     4     void doSomething();5 6     int hashCode();  // Object类中的方法7 }

4、Lambda表达式示例

　　需求一：开启一个线程，在线程中打印出"Hello World"

　　未使用Lambda表达式时的写法：

1 public class LambdaTest { 2  3     public void print() { 4  5         Thread thread = new Thread(new Runnable() { 6             @Override 7             public void run() { 8                 System.out.println("Hello World"); 9             }10         });11 12         thread.start();13     }14 }

　　使用Lambda时的写法：

1 public class LambdaTest {2     3     public void print() {4         Thread thread = new Thread(() -> System.out.println("Hello World"));5     }6 }

　　需求二：模拟一个计算器，使其可以进行简单的加、减、乘操作

　　（1）、计算器操作函数式接口

1 @FunctionalInterface2 public interface Calculator
     
       {3     T operation(T t1,T t2);4 }
     

　　（2）具体操作

1 public class CalculatorTest { 2  3     public Integer operator(Integer v1,Integer v2,Calculator
     
       calculator) { 4         return calculator.operation(v1,v2); 5     } 6  7     public Integer add(Integer v1,Integer v2) { 8         return operator(v1,v2,(x,y) -> x + y); 9     }10 11     public Integer subtr(Integer v1,Integer v2) {12         return operator(v1,v2,(x,y) -> x - y);13     }14 15     public Integer multi(Integer v1,Integer v2) {16         return operator(v1,v2,(x,y) -> x * y);17     }18 19     public static void main(String[] args) {20 21         CalculatorTest calculatorTest = new CalculatorTest();22 23         // 加法24         Integer add = calculatorTest.add(1,2);25 26         // 减法27         Integer sub = calculatorTest.subtr(100,82);28 29         // 乘法30         Integer multi = calculatorTest.multi(5,3);31 32         System.out.println(add);33         System.out.println(sub);34         System.out.println(multi);35     }36 }
     

　　运行结果：

31815

　　从需求一中，我们可以看出，使用Lambda比使用匿名内部类代码更加简洁，同时，也可以理解为什么Lambda必须需要函数式接口的支持。我们假设Runnable中有两个方法，那么，“() -> System.out.println(Thread.currentThread().getName())”应该去找哪个方法去实现？

　　从需求二的例子中，我们可以更加理解“一段可以传递的代码”这句话的含义。对数据的操作方法定义在Calculator接口中，而加、减、乘的具体实现代码在各自的方法中，并将这些实现作为参数传递给CalculatorTest类的operator()方法，最终返回操作结果。

5、Lambda表达式的语法

5.1 Lambda表达式的语法结构

(参数列表，对应的是接口中对应的抽象方法的参数列表) -> {对抽象方法的实现}

　　Lambda表达式语法分在3个部分：

1. 左边的参数列表，对应的是函数式接口中抽象方法的参数列表；
2. 中间的符号:->,为固定写法; 
3. 右边大括号内对函数接口抽象方法的实现。

　　Lambda表达式的在具体场景下可以有简略写法。

5.2 语法格式一：无参数，无返回值

1 Runnable runnable = () -> {System.out.println("Hello World");} 2 Runnable runnable = () -> System.out.println("Hello World");  // 简写形式

　　此时，如果右边的代码简单，只有一行代码时，{}可以省略。

5.2 语法格式二：有一个参数，无返回值

1 public class CalculatorTest { 2  3     public void print(Consumer
     
       msg) { 4         System.out.println(msg); 5     } 6      7     public void doPrint(String msg) { 8         print((str) -> System.out.println(msg)); 9         print(str -> System.out.println(msg));  // 简写10 11     }12 }
     

　　此时，左边的()可以省略。

5.3 语法格式三：Lambda体内只有一条语句，且有返回值，return可省略

1 public Integer subtr(Integer v1,Integer v2) {2     return operator(v1,v2,(x,y) -> x - y);3 }

5.4 语法格式四：有两个以上参数，且Lambda体中有多条语句

1 public Integer add(Integer v1,Integer v2) {2         return operator(v1,v2,(x,y) -> {3             System.out.println("进行加法运算");4             return x + y;5         });6     }

5.5 语法格式五：Lambda表达式的数据类型可以省略不写

　　JVM编译器通过上下文可以推断出数据类型，但要注意的是，当多个参数时，要么都写，要么都不写，不能有的写，有的不写：

1 public Integer subtr(Integer v1,Integer v2) {2         return operator(v1,v2,(Integer x,y) -> x - y);   // 错误3     }4 5 public Integer subtr(Integer v1,Integer v2) {6         return operator(v1,v2,(x,y) -> x - y);    // 正确7     }

6、Java8四大内置核心函数式接口

Consumer
     
       : 消费型接口（无返回值，有去无回）         void accept(T t); Supplier
      
        : 供给型接口         T get();          Function
       
         : 函数型接口        R apply(T t);         Predicate
        
          : 断言型接口        boolean test(T t);        四大核心接口的-->扩展子接口
        
       
      
     

　　示例：

1 import lombok.Getter; 2 import lombok.Setter; 3  4 import java.util.function.Consumer; 5 import java.util.function.Function; 6 import java.util.function.Predicate; 7 import java.util.function.Supplier; 8  9 @Getter10 @Setter11 class User {12     private String username;13     private int age;14 15     @Override16     public String toString() {17         return "User{" +18                 "username='" + username + '\'' +19                 ", age=" + age +20                 '}';21     }22 }23 24 public class InnerInterface {25 26     /**27      * 打印user信息28      */29     public void print(User user,Consumer
     
       userConsumer) {30         userConsumer.accept(user);31     }32 33     /**34      * 返回一个user35      */36     public User getUser(Supplier
      
        userSupplier) {37         return userSupplier.get();38     }39 40     /**41      * 转换一个user42      */43     public User transformUser(User user,Function
       
         function) {44         return function.apply(user);45     }46 47     /**48      * 检验User是否合法49      */50     public boolean checkUser(User user, Predicate
        
          predicate) {51         return predicate.test(user);52     }53 54     public static void main(String[] args) {55 56         User userObj = new User();57         userObj.setUsername("西门吹雪");58         userObj.setAge(22);59 60         // 测试Consumer61         InnerInterface mainInst = new InnerInterface();62         mainInst.print(userObj,user -> System.out.println(user));63 64         // 测试Supplier65         final User user1 = mainInst.getUser(() -> {66             User user = new User();67             user.setUsername("叶孤城");68             user.setAge(22);69             return user;70         });71         System.out.println(user1);72         73         // 将西门吹雪的年龄改为2574         final User user2 = mainInst.transformUser(userObj, (user -> {75             user.setAge(25);76             return user;77         }));78         System.out.println(user2);79 80         // 判断User是否是西门吹雪81         final boolean checkUser = mainInst.checkUser(userObj, (user -> user.getUsername().equals("西门吹雪")));82         System.out.println(checkUser);83     }84 }
        
       
      
     

　　运行结果：

User{username='西门吹雪', age=22}User{username='叶孤城', age=22}User{username='西门吹雪', age=25}true

 　　以上四大核心内置接口是我们日常开发中经常要用到的，同时，它们还有一些变种，如：

　　BiConsumer，Consumer的增强版，接受两个参数：

1 @FunctionalInterface2 public interface BiConsumer
     
       {3 4     void accept(T t, U u);5 }
     

　　BiFunction类似，Function的增强版，接受两个参数，返回一个参数：

1 @FunctionalInterface 2 public interface BiFunction
     
       { 3  4     R apply(T t, U u); 5      6     default 
      
        BiFunction
       
         andThen(Function
         after) { 7         Objects.requireNonNull(after); 8         return (T t, U u) -> after.apply(apply(t, u)); 9     }10 }
       
      
     

　　其他的类似，这些函数式接口都在java.util.function包下，读者可去这个包下去查询。