java8-四大内置核心函数式接口

1.前言

在上一篇文章(java8初步-为什么使用lambda表达式)中,我们已经知道使用lambda表达式可以大大简化我们的代码量,使得代码可阅读性,逻辑性更强,不过美中不足的是我们需要自己编写一个接口,再在具体的方法中调用该接口使用lambda表达式进行简化,如下(代码源自上一篇文章):

//过滤接口
public interface MyFilter<T> {
    boolean test(T t);
}

/**
     * 价格大于50 ,lambda改进方法
     * @return
     */
    @Test
    public List<Apple> lambda_test5() {
        List<Apple> filterApple = filterApples(this.apples, (MyFilter<Apple>) apple -> apple.getPrice() > 50);
        return filterApple;
    }

可以看到,我们是自己创建了一个MyFiter<T> 接口,后面在自己写了一个filterApples(List<Apple> apples, MyFilter myFilter)方法来具体实现苹果的筛选.但是实际上java8中已经内置了4种基础的函数式接口供我们调用.

四大内置核心函数式接口.png

下面我们就简单学习下这四种函数的用法.

2.四大内置核心函数式接口

他们分别是位于java.util.function 的Consumer,Supplier,Function以及Predicate 接下来简单使用下这四个接口.

/*
 * Java8 内置的四大核心函数式接口
 * 
 * Consumer<T> : 消费型接口
 *      void accept(T t); 
 * 
 * Supplier<T> : 供给型接口
 *      T get(); 
 * 
 * Function<T, R> : 函数型接口
 *      R apply(T t);
 * 
 * Predicate<T> : 断言型接口
 *      boolean test(T t);
 * 
 */

2.1 Consumer<T> 接口

Consumer<T> 接口是一个消费型接口, 消费性接口顾名思义就是消费,它传入一个T t 参数,返回值为void, 使用accept(T t)方法接受t并且不做任何返回.

   @Test
    public void Consumer_test(){
        happy(10, (m) -> System.out.println("我买了个苹果,花费：" + m + "元"));
    }

    public void buyApple (int money, Consumer<Interger> consumer){
        consumer.accept(money);
    }

这样我们就消费了money,购买了苹果.

2.2 Supplier<T>

Supplier<T> 是供给型接口,通过其get()方法返回一个我们需要的对象,我们使用Supplier产生指定个数的整数，并返回一个集合.

    @Test
    public void supplierTest(){
        List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));
        numList.forEach(System.out::println); // 这里其实是使用了consumer接口,在加上类::方法 循环输出
    }
    
    //需求：产生指定个数的整数，并放入集合中
    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;
    }

getNumList(10, () -> (int)(Math.random() * 100))中的第二个参数就是对Supplier.get() 方法的实现返回一个int类型的值.

2.3 Function<T, R> 接口

Function<T, R> 接口是一个函数型接口,他表示接受一个T型参数,返回一个R型参数,使用其R apply(T t)方法.R与T 可以是同一种类型,我们可以传入一个int 返回一个传入值的十倍的值.

@Test
    public void functionTest(){
        Integer val = resize(5, x -> x * 10);
        System.out.println(val);
    }

    //需求：返回一个十倍的值
    public Integer resize(int val, Function<Integer, Integer> fun){
        return fun.apply(val);
    }

2.4 Predicate<T>接口

Predicate<T> 是一个断言型接口,返回的是boolean值,用来返回正确与否.我们实现一个方法,判断传入的值是否大于5如果大于5就放入一个list.

    @Test
    public void predicateTest(){
        List<Integer> list = Arrays.asList(2, 4, 6, 8, 10);
        List<Integer> integers = filterInt(list, (val) -> val > 5);

        integers.forEach(System.out::println);

    }

    //需求：将满足条件的字符串，放入集合中
    public List<Integer> filterInt(List<Integer> list, Predicate<Integer> pre){
        List<Integer> integers = new ArrayList<>();

        for (Integer val : list) {
            if(pre.test(val)){
                integers.add(val);
            }
        }

        return integers;
    }

3.其他函数式接口

除了这四种核心的接口之外,还有其他类似于这四种接口改进的接口,其实功能大同小异,只不过传入参数个数有所区别,使用这些接口可以让我们的开发变得更加高效,迅速.

扩展.png