Lambda表达式(偷懒直接贴代码)

/**
 * <p>
 *      lambda介绍:
 *          1.格式：->      lambda操作符或箭头操作符
 *                 ->左边   lambda形参列表 是方法的形参列表（其实就是接口中抽象方法的形参列表）
 *                 ->右边   lambda方法体（其实就是重写抽象方法的方法体）
 *
 *          2.Lambda使用（分为6种情况：下面的测试方法分为每种情况的介绍）
 *
 *          3.Lambda表达式本质：作为函数式接口的实例
 *
 *          4.Lambda总结：
 *                  lambda左边 参数类型可以省略(如果参数只有一个括号可以省略，多个则不能省略)
 *                  lambda右边  lambda方法体一般都使用大括号（如果方法体只有一个语句 则可以省略大括号和return）
 *                  其中如果省略了大括号则return必须要省略
 *
 *          5.函数式接口：
 *                  接口中只有只声明一个抽象方法，则此接口就称为函数式接口 其中有@FunctionalInterface
 *
 * </p>
 * @classname: LambdaTest
 * @description: Lambda表达式
 * @author: zhangjun
 * @date: 2019/5/24 14:09
 * @version  1.0
 */
public class LambdaTest {

    /**
     * 语法格式1.无参 无返回值
     * @author zhangjun
     * @datetime  2019/5/24 14:28
     * @param
     * @return
     */
    @Test
    public void test1(){
        // 原始方法
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是原始方法");
            }
        };
        // lambda方法
        Runnable ru = () -> System.out.println("我是Lambada表达式");
        ru.run();
    }

    /**
     * 语法格式2.有参 无返回值
     * @author zhangjun
     * @datetime  2019/5/24 14:31
     * @param
     * @return
     */
    @Test
    public void test2(){
        // 原始方法
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("有参 无返回值");
        // lambda方法
        Consumer<String> consumer1 = (String s) -> {
            System.out.println(s);
        };
        consumer1.accept("有参 无返回值");
    }

    /**
     * 语法格式3：数据类型可以省略 因为可由编译器推断得出，称为 "类型守护"
     * @author zhangjun
     * @datetime  2019/5/24 14:36
     * @param
     * @return
     */
    @Test
    public void test3(){
        Consumer<String> consumer = (s) ->{
            System.out.println(s);
        };
        consumer.accept("数据类型可以省略 因为可由编译器推断得出");
    }

    /**
     * 语法格式4：Lambda若只有一个参数，参数的小括号也是可以省略的
     * @author zhangjun
     * @datetime  2019/5/24 14:40
     * @param
     * @return
     */
    @Test
    public void test4(){
        Consumer<String> consumer = s->{
          System.out.println(s);
        };
        consumer.accept("Lambda若只有一个参数，参数的小括号也是可以省略的");
    }

    /**
     * 语法格式5：Lambda需要两个或者两个以上的参数 ，多条执行语句，并且可以有返回值
     * @author zhangjun
     * @datetime  2019/5/24 14:45
     * @param
     * @return
     */
    @Test
    public void test5(){
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return Integer.compare(o1,o2);
            }
        };

        Comparator<Integer>  comparator1 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return Integer.compare(o1,o2);
        };

        System.out.println(comparator1.compare(1,2));
    }

    /**
     * 语法格式6：当Lambda表达式体只有一条语句时,return和大括号若有 都可以省略
     * @author zhangjun
     * @datetime  2019/5/24 14:50
     * @param
     * @return
     */
    @Test
    public void test6(){
        Comparator<Integer> comparator = (o1,o2) -> Integer.compare(o1,o2);
        System.out.println(comparator.compare(1,2));
    }
}