Lambda表达式

我们都知道java是个静态语言。而静态语言和动态语言很大的一个区别就是动态语言可以忽略函数的参数类型，实现自动的推断。在jdk8以后，java为了迎合动态语言的特性，增加了lambda表达式，其实更重要的是他简化了方法的书写逻辑。

现在进入正题：

lambda的适用范围：必须是 函数式接口 或者 只有一个抽象方法的抽象类（注：这个一个的意思很广泛，意思是该接口新增的抽象方法只有一个也算）
什么叫函数式接口？？
看到接口，抽象类上面加了注解@FunctionalInterface ，那么该类（接口）就是函数式接口。
JDK自带的四大核心函数式接口：

断言型

有参，返回布尔

    @Test
    public void test01(){//断言型  有参，返回布尔
        Predicate<Integer> p = num -> num<9;
        //上面的等价于下面的
//        Predicate<Integer> p = (num) -> {return num<9;};
        System.out.println(p.test(100));
        System.out.println(p.test(3));
    }

消费型

有参，无返回

    @Test
    public void test03(){//消费性   有参，无返回
        Consumer<String> c = x -> System.out.println("你好！"+x);
        c.accept("卢先生");
    }

函数型

有参，有返回

    @Test
    public void test05(){//函数型  有参，有返回
        Function<String,String> f = (s) -> s.toUpperCase();
        System.out.println(f.apply("abc"));
    }

供给型

    @Test
    public void test04(){//供给型  无参，有返回
        Supplier<Integer> supplier = () -> 999;
        System.out.println(supplier.get());//999
    }

除了上面的用法，还可以将lambda表达式作为形参

	@Test
    public void test01(){
        String s = upper((x) -> x.toUpperCase(),"aac");
        System.out.println(s);
    }

    public String upper(Function<String,String> fun,String str){
        return fun.apply(str) ;
    }


    @Test
    public void test02(){
        myPredicate(x -> x<18,10);//判断值是否小于18
    }


    public void myPredicate(Predicate<Integer> pre,Integer num){
        System.out.println(pre.test(num));
    }

还可以引用相同类型的现成方法

    @Test//用断言型  模拟  ArrayList中的add方法，因为add方法也是有参返回布尔
    public void test01(){
        ArrayList<String> list = new ArrayList<>();
        Predicate<String> pre = list::add;
        pre.test("a");
        pre.test("b");
        System.out.println(list);
    }