函数式接口与Lambda表达式

函数式接口：接口中只有一个抽象方法的接口，称为函数式接口

Java8中内置的核心的四大函数式接口。

一 、消费型接口

Consumer<T>     接收一个 T 类型
    void accept(T t);

    public void eat(double money,Consumer<Double> con){
        con.accept(money);
    }

    @Test
    public void consumer(){
        eat(100,m-> System.out.println("吃饭消费了"+m+"元"));
    }

 输出结果为

---

二 、供给型接口  

Supplier<T>     返回T类型对象
  T  get();

   /**
     * 生成指定数量的整数并存入到集合
     * @param num
     * @param sup
     * @return
     */
    public List<Integer> getNumList(int num, Supplier<Integer> sup){
        List<Integer> list=new ArrayList<>();

        for (int i = 0; i < num; i++) {
            Integer n=sup.get();
            list.add(n);
        }
        return list;
    }

    @Test
    public void supplier(){
        List<Integer> numList=getNumList(10,()->(int)(Math.random()*100));
        for (Integer num:numList){
            System.out.println(num);
        }
    }

 输出结果

---

三 、函数型接口

Function<T, R>  由T类型对象转成R类型对象
    R apply(T t);

   //处理字符串
    public String strHandler(String str, Function<String,String> fun){
        //允许调用某一个对象的一个方法,并且用指定的一个对象替换当前的对象.
        return fun.apply(str);
    }

    @Test
    public void function(){
        String newStr=strHandler("\t\t Function",str ->str.trim());
        System.out.println(newStr);
        String subStr=strHandler("Function",s -> s.substring(2,5));
        System.out.println(subStr);
    }

输出结果

---

四 、断言型接口

Predicate<T>    条件判断
    boolean test(T t);

/**
     * 将满足条件的字符串放入集合中
     * @param list
     * @param pre
     * @return
     */
    public List<String> filterStr(List<String> list, Predicate<String> pre){
        List<String> stringList=new ArrayList<>();
        for (String str:stringList){
            if (pre.test(str)){
                stringList.add(str);
            }
        }
        return stringList;
    }

    @Test
    public void predicate(){
        List<String> list=Arrays.asList("Hello","predicate","lambda","zxf","yh");
        List<String> stringList=filterStr(list,s -> s.length()>3);
        for (String str:stringList){
            System.out.println(str);
        }
    }

输出结果：

---

Lambda表达式也可称为闭包(定义在一个函数内部的函数)

它允许把函数作为另一个方法的参数(函数作为参数传递进方法中)

同时，lambda只支持函数式接口，即只有一个抽象方法的接口

可以使用注解@FunctionalInterface 修饰，可以检查是否是函数式接口。

Lambda 表达式的参数列表中参数的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”

---

基本语法

(参数) -> (表达式)

或

(参数) -> (语句)

-> ： 箭头操作符将 Lambda 表达式拆分成两部分：
左侧：Lambda 表达式的参数列表；
右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体；

---

语法举例

一 、无参无返回值

 @Test
    public void lambda(){
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello Lambda!!!");
            }
        };
        runnable.run();
        System.out.println("-----------------------------");
        Runnable runnable1=()-> System.out.println("Hello Lambda!!!");
        runnable1.run();
    }

输出结果为

---

二 、有一个参，无返回值(只有一个参数是lambda表达式的参数X的小括号可以省略不写)

 @Test
    public void lambda2(){
        Consumer<String> con=x-> System.out.println(x);
        con.accept("有一个参，无返回值");
    }

输出结果为

---

三 、有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

    @Test
    public void lambda3(){
        Comparator<Integer> comparator=(x,y)->{
            System.out.println("111");
            return Integer.compare(x,y);
        };
    }

---

四 、若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写

   @Test
    public void lambda4(){
        Comparator<Integer> comparator=(x,y)-> Integer.compare(x,y);
    }

参考地址：Mason啊 - 简书