java8新特性，lambda表达式基本语法使用

1. 本质：函数式接口的实例

2. 格式

   ① 操作符 - >
   ② 左 边：Lambda参数列表 （其实就是接口中的抽象方法的形参列表）
   ③ 右 边：Lambda体 （其实就是重写的抽象方法的方法体）

3. 什么是函数式接口
   ① 只包含一个抽象方法的接口，称为函数式接口
   ② 可通过Lambda表达式创建该接口的对象
   ③ 可以在一个接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明该接口是一个函数式接口。
   ④ 在java.util.function包下定义了Java8丰富的函数式接口

4.  接下来是具体实现，首选创建6个函数式接口，在创建测试的demo

   //没有返回值多个参数
   @FunctionalInterface
   public interface NoneReturnMultipleParameter {
       void test(int a,int b);
   }

   //没有返回值没有参数
   @FunctionalInterface
   public interface NoneReturnNoneParameter {
           void test();
   }

   //没有返回值一个参数
   @FunctionalInterface
   public interface NoneReturnSingleParameter {
       void test(int a);
   }

   //有返回值，有多个参数
   @FunctionalInterface
   public interface SingleReturnMultipleParameter {
       int test(int a,int b);
   }

   //有返回值，没有参数
   @FunctionalInterface
   public interface SingleReturnNoneParameter {
       int test();
   }

   //有返回值，有一个参数
   @FunctionalInterface
   public interface singleReturnSingleParameter {
       int test(int a);
   }

   /**
    * 精简：1.参数类型可以省略因为在接口方法定义了（要省略就都省略，否则都别省略）
    *       NoneReturnMultipleParameter lambda3 = (a,b) -> {
    *             System.out.println(a + b + "实现一个多个参数有返回值的函数式接口");
    *         };
    *      2.参数列表 有且只有一个 的时候，小括号()可以省略
    *      NoneReturnSingleParameter lambda2 = a -> {
    *             System.out.println(a + "实现无参一个返回值的函数式接口");
    *         };
    *      3.方法体里面 只有一句代码 时，大括号{}可以省略
    *      NoneReturnNoneParameter lambda1 = () -> System.out.println("实现无参无返回值的函数式接口");
    *      4.方法体里面 只有一句代码并且该代码是返回语句return 时，return可以省略
    *      singleReturnSingleParameter lambda6 = a -> a * a;
    */
   public class BasicPro {
       public static void main(String[] args) {
           //1.参数类型可以省略因为在接口方法定义了（要省略就都省略，否则都别省略）
           NoneReturnMultipleParameter lambda3 = (a, b) -> {
                 System.out.println(a + b + "实现一个多个参数没有返回值的函数式接口");
             };
           lambda3.test(467,988);
   
           //2.参数列表 有且只有一个 的时候，小括号()可以省略
           NoneReturnSingleParameter lambda2 = a -> {
                 System.out.println(a + "实现无参一个返回值的函数式接口");
           };
           lambda2.test(45);
   
           //3.方法体里面 只有一句代码 时,大括号{}可以省略
           NoneReturnNoneParameter lambda1 = () -> System.out.println("实现无参无返回值的函数式接口");
           lambda1.test();
   
           //4.方法体里面 只有一句代码并且该代码是返回语句return 时，return可以省略
           singleReturnSingleParameter lambda6 = a -> a * a;
           System.out.println(lambda6.test(24));
       }
   }

   /**
    * 精简：1.参数类型可以省略因为在接口方法定义了（要省略就都省略，否则都别省略）
    *       NoneReturnMultipleParameter lambda3 = (a,b) -> {
    *             System.out.println(a + b + "实现一个多个参数有返回值的函数式接口");
    *         };
    *      2.参数列表 有且只有一个 的时候，小括号()可以省略
    *      NoneReturnSingleParameter lambda2 = a -> {
    *             System.out.println(a + "实现无参一个返回值的函数式接口");
    *         };
    *      3.方法体里面 只有一句代码 时，大括号{}可以省略
    *      NoneReturnNoneParameter lambda1 = () -> System.out.println("实现无参无返回值的函数式接口");
    *      4.方法体里面 只有一句代码并且该代码是返回语句return 时，return可以省略
    *      singleReturnSingleParameter lambda6 = a -> a * a;
    * 下面是基础语法部分
    */
   public class BasicSyntax {
       public static void main(String[] args) {
           //1. 实现无参无返回值的函数式接口
           NoneReturnNoneParameter lambda1 = () -> {
               System.out.println("实现无参无返回值的函数式接口");
           };
           lambda1.test();
   
           // 2. 实现无参一个返回值的函数式接口
           NoneReturnSingleParameter lambda2 = (int a) -> {
               System.out.println(a + "实现无参一个返回值的函数式接口");
           };
           lambda2.test(100);
   
           // 3.实现一个多个参数有返回值的函数式接口
           NoneReturnMultipleParameter lambda3 = (int a,int b) -> {
               System.out.println(a + b + "实现一个多个参数有返回值的函数式接口");
           };
           lambda3.test(34,45);
   
           // 4.实现多个参数有返回值的函数式接口
           SingleReturnMultipleParameter lambda4 = (int a,int b) -> {
               int c = a + b;
               return c;
           };
           int ret1 = lambda4.test(238, 594);
           System.out.println(ret1 + "实现多个参数有返回值的函数式接口");
   
           // 5. 实现无参数有返回值的函数式接口
           SingleReturnNoneParameter lambda5 = () -> {
               return 54;
           };
           int ret2 = lambda5.test();
           System.out.println(ret2 + "实现无参数有返回值的函数式接口");
   
           // 6. 实现有一个参数有返回值的函数式接口
           singleReturnSingleParameter lambda6 = (int a) -> {
               return a * a;
           };
           int res3 = lambda6.test(23);
           System.out.println(res3 + "实现有多个参数有返回值的函数式接口");
       }
   }

   上面的两个demo的运行结果

5.