java8新特性lambda

/**
 * lambda表达式的使用举例
 *   1. 举例：（o1,o2） -> Integr.compare(o1,o2);
 *   2.格式
 *       ->：lambda操作符 或者 箭头操作符
 *       -> 左边 lambda 形参列表（其实就是接口中的抽象方法的形参列表）
 *       -> 右边 lambda体（其实就是重写的抽象方法的方法体）
 *   3.lambda表达式的使用：分为六种情况介绍；
 *
 *
 *   4.lambda表达式的本质：作为函数式接口的实例
 *   5.函数式接口：如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口;
 *              函数式接口都被这个注解修饰了：@FunctionalInterface，没有这个注解只要符合一个接口中，声明了一个抽象方法也叫函数式接口；
 *              @FunctionalInterface 注解只是起到了检测的作用；
 *   6.总结：
 *      ->左边：lambda形参列表的参数类型可以省略（类型推断）；如果只有一个参数的话，括号可以省略，两个的话参数就不能省略
 *      -> 右边 lambda体： 如果lambda体只有一个执行语句就可以省略return 和大括号可以省略;
 */

public class LambdaTest {

    /**
     * 语法格式一：无参，无返回值的
     */
    @Test
    public void test1(){
       Runnable r1=new Runnable() {
           public void run() {
               System.out.println("我爱北京天安门你");
           }
       };

       r1.run();
        System.out.println("***********************************");
        Runnable r2= () -> System.out.println("我爱故宫");

        r2.run();
    }

    /**
     * Comparator java提供了一个用于比较的接口，提供了一个比较的方法compare；
     *  语法格式三：有参，有返回值
     */
    @Test
    public void  Test2(){
        Comparator<Integer> com1= new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {

                return Integer.compare(o1,o2);
            }
        };
        System.out.println(com1.compare(15,16));
        System.out.println("************************************");
        //lambda表达式
        Comparator<Integer> com2=(o1,o2)-> Integer.compare(o1,o2);
        System.out.println(com2.compare(17,16));
        System.out.println("****************更简洁的**********************");
        //方法引用
        Comparator<Integer> com3=Integer :: compare;
        System.out.println(com3.compare(18,16));
    }

    /**
     * Consumer:java.util.function中 Function, Supplier, Consumer,
     *          Predicate和其他函数式接口广泛用在支持lambda表达式的API中。
     *          这些接口有一个抽象方法，会被lambda表达式的定义所覆盖。
     *          Consumer的作用顾名思义,是给定义一个参数,对其进行(消费)处理,
     *          处理的方式可以是任意操作.
     *
     * @FunctionalInterface
     *  语法格式三：一个参数，但是没有返回值
     */
    @Test
    public void  Test3(){
        Consumer<String> con =new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);

            }
        };
        con.accept("谎言和誓言的区别是什么?");
        System.out.println("*************lambda**********************");
        Consumer<String> con2=s -> System.out.println(s);
        con2.accept("听的人当真了，说的人也当真了");
    }

    /**
     * 格式五：lambda 需要两个或者以上的参数，多条执行语句，并且可以返回值
     */
    @Test
    public void Test(){
       Comparator<Integer> com =new Comparator<Integer>() {
           @Override
           public int compare(Integer o1, Integer o2) {
               System.out.println(o1);
               System.out.println(o2);
               return Integer.compare(o1,o2);
           }
       };
        System.out.println(com.compare(13,4));
        System.out.println("***********************************");
        Comparator<Integer> com2= (o1,o2)->{
            System.out.println(o1);
            System.out.println(o2);
            return Integer.compare(o1,o2);
        };
        System.out.println(com2.compare(23,7));
    }

    /**
     * 语法格式六：当lambda体只有一条语句时，return 与大括号或者都可以省略
     */
    @Test
    public void Test6(){
        Comparator<Integer> com =new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(com.compare(13,4));
        System.out.println("***********************************");
        Comparator<Integer> com2=(o1,o2) ->  o1.compareTo(o2);
        System.out.println(com2.compare(13,4));
    }
}