Lambda表达式

        Java8新特性

/**
     * Lambda表达式1
     * ->:Lambda操作符或箭头操作符
     * ->左边：Lambda形参列表(接口中抽象方法的形参列表)
     * ->右边：Lambda体(重写的抽象方法的方法体)
     */

    /**
     * 语法格式一:无参，无返回值
     */
    @Test
    public void lambda(){
        //一般写法
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("天安门");
            }
        };
        r1.run();

        //Lambda写法
        Runnable r2 = () ->{
            System.out.println("故宫");
        };
        r2.run();
    }

    /**
     * 语法格式二:有参，无返回值
     */
    @Test
    public void lambda0(){
        //一般写法
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("1000-7等于多少?");

        //Lambda写法1
        Consumer<String> con1=(String s)->{
            System.out.println(s);
        };
        con1.accept("993");

        /**
         * 语法格式三:数据类型可以省略，因为可以由编译器推断得出，称为‘类型推断’
         * 语法格式四:若只需一个参数，参数的小括号可以省略
         * 语法格式五:当Lambda体只有一条语句，return和大括号都可以省略
         */
        //Lambda写法2
        Consumer<String> con2=s->System.out.println(s);
        con1.accept("993");
    }

    /**
     * 语法格式六:有多个参数，多条执行语句，且有返回值
     */
    @Test
    public void lambda1(){
        //一般写法
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("1");
                System.out.println("2");
                System.out.println("3");
                return Integer.compare(o1, o2);
            }
        };
        //Lambda写法1
        Comparator<Integer> com2=(o1,o2)-> {
            System.out.println("1");
            System.out.println("2");
            System.out.println("3");
            return Integer.compare(o1, o2);
        };
    }

 函数式接口

/**
     * Lambda表达式的本质就是函数式接口
     * 匿名实现类都可以使用Lambda表达式来写
     * 如果一个接口中只声明了一个抽象方法，则此接口就称为函数式接口
     *例如:
     @FunctionalInterface
         interface Lam{
             void Method();
         }
     */
    @Test
    public void test1(){
        //一般写法
        happy(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("价格为"+aDouble);
            }
        });
        //Lambda表达式写法
        happy(400,money->System.out.println("价格为"+money));
    }
    public void happy(double money,Consumer<Double> con){
        con.accept(money);
    }


    @Test
    public void test2(){
        //一般写法
        List<String> list = Arrays.asList("北京", "南京", "上海");
        List<String> file1 =file(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(file1);
        //Lambda表达式写法
        List<String> file2 =file(list,s->s.contains("京"));
        System.out.println(file2);
    }
    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> file(List<String> List, Predicate<String> pre){
        ArrayList<String> arr = new ArrayList<>();
        for (String s:List){
            if (pre.test(s)){
                arr.add(s);
            }
        }
        return arr;
    }

方法引用

/**
     * 方法引用的使用情况
     * 1.当要传递给Lambda体的操作，已有实现方法，就可以使用方法引用
     * 具体三种情况,返回值和形参一致时用1,2 形参不同时考虑第三种
     * 对象：：非静态方法
     * 类：：静态方法
     * 类：：非静态方法
     */

    /**
     情况1:对象::实例方法
     Consumer中的void accept方法
     PrintStream中的void println方法
     **/
    @Test
    public void method(){
        //Lambda写法
        Consumer<String> con1=str-> System.out.println(str);
        con1.accept("你好");
        //方法引用写法
        PrintStream pr=System.out;
        Consumer<String> con2=pr::println;
        con2.accept("hi");
    }

    /**
     * 情况二：类::静态方法
     *Comparator中的int compare(T t1,T t2)
     *Integer中的int compare(T t1,T t2)
     *
     * Function中的R apply(T t)
     * Math中的Long round(Double d)
     */
    @Test
    public void method2(){
        //Lambda写法
        Comparator<Integer> com1=(t1,t2)->Integer.compare(t1,t2);
        System.out.println(com1.compare(12,13));
        //方法引用写法
        Comparator<Integer> com2=Integer::compare;
        System.out.println(com2.compare(13,12));

        //Lambda写法
        Function<Double,Long> f1=d->Math.round(d);
        System.out.println(f1.apply(12.3));
        //方法引用写法
        Function<Double,Long> f2=Math::round;
        System.out.println(f2.apply(13.2));
    }

    /**
     * 情况三：类：：实例方法
     *Comparator中的int compare(T t1,T t2)
     * String中的int t1.compare(t2)
     * t1成为方法的调用者，t2成为方法的形参
     */
    @Test
    public void method3(){
        //Lambda写法
        Comparator<String> com1=(s1,s2)->s1.compareTo(s2);
        System.out.println(com1.compare("a","b"));
        //方法引用写法
        Comparator<String> com2=String::compareTo;
        System.out.println(com2.compare("b","a"));
    }

数组引用

/**
     * 数组引用
     *Function中的R apply(T t)
     */
    @Test
    public void method4(){
        //Lambda表达式
        Function<Integer,String[]> f1= len -> new String[len];
        String[] apply = f1.apply(7);
        System.out.println(Arrays.toString(apply));
        //数组引用
        Function<Integer,String[]> f2=String[]::new;
        String[] apply1 = f2.apply(5);
        System.out.println(Arrays.toString(apply1));
    }