java8 lambda表达式-内置四大函数式接口(Consumer、Supplier、Function、Predicate)

说明

我们想使用 lambda表达式,需要创建 函数式接口,频繁创建接口,繁琐,也造成接口太多

一般 常用的 函数式接口,就不需要创建了,直接使用这 四大函数式接口 即可

java.util.function 包内 , 有Java 内置核心四大函数式接口

应用场景

不需改动 的代码封装到方法中,方法有2个形参:

  1. 数据
  2. 核心算法

调用时,只需传入 数据核心算法 即可

Consumer 消费型接口

抽象方法

接收一个参数,对该 参数 进行处理,没有返回值

void accept(T t);

案例

定义一个 handle 方法,可以传入 数据Consumer

public class ConsumerTest {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("李雷", "韩梅梅", "lucy", "lili");
        //lambda表达式写法
        handle(list, t -> System.out.println(t));
        //方法引用写法
        handle(list, System.out::println);
    }

    public static void handle(List<String> list, Consumer<String> con){
        for ( String item : list) {
            con.accept(item);
        }
    }
}

Supplier 供给型接口

抽象方法

没有形参,返回一个结果

T get();

不常使用

案例

public class SupplierTest {

    public static void main(String[] args) {
        // lambda表达式写法
        randomList(10 , () -> Math.random() );
        // 方法引用写法
        randomList(10 , Math::random);
    }

    public static List<Double> randomList(int num, Supplier<Double> sup){
        List<Double> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            Double n = sup.get();
            list.add(n);
        }
        return list;
    }
}

Predicate 断定型接口

抽象方法

接收一个参数,判断该 参数 是否满足条件,满足条件返回 true,否则返回 false

boolean test(T t);

例子

定义一个 filter 方法,传入 数据Predicate 判断条件

public class PredicateTest {
    //将不需改动的代码封装到方法中,传入数据 和 核心算法
    public static List<String> filter(List<String> list, Predicate<String> pre){
        List<String> retList = new ArrayList<>();
        for (String str : list) {
            if(pre.test(str)){ //Predicate判断是否符合条件
                retList.add(str);
            }
        }
        return retList;
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList("李雷", "韩梅梅", "lucy", "lili","李四");

        List<String> resList = filter(list, (s) -> "李".equals(s.substring(0,1)));
        for (String item : resList) {
            System.out.println(item);
        }
    }
}

Function 函数型接口

抽象方法

传入参数,返回一个结果

R apply(T t);

案例

public class FunctionTest {

    public static void main(String[] args) {
        String[] array = new String[]{"90","80","85","92"};

        //lamb表达式
        List list = handle(array,s -> Integer.parseInt(s));
        System.out.println(list);

        //方法引用
        List list2 = handle(array,Integer::parseInt);
        System.out.println(list2);

    }
    public static List<Integer> handle(String[] array, Function<String,Integer> fun){
        List<Integer> retList = new ArrayList<>();
        for(String item : array){
            int i = fun.apply(item); // 调用 apply() 方法
            retList.add(i);
        }
        return retList;
    }
}

感谢:
https://www.cnblogs.com/myseries/p/13873788.html


原文出处:https://www.malaoshi.top/show_1IX36DpAWg8i.html