【Java】24 常用函数式接口

时间:2022-07-26
本文章向大家介绍【Java】24 常用函数式接口,主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

JDK 提供了 大量常用的函数式接口以丰富 Lambda 的典型使用场景,它们主要在 java.util.function 包中。

1.1 Supplier 接口

java.util.function.Supplier<T>接口仅包含一个无参的方法:T get( )。用来获取一个泛型参数指定类型的对象数据。java.util.function.Supplier<T>接口被称之为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会生成什么类型的数据

1.1.1 示例代码

public class Demo {
    public static int getMax(int[] arr, Supplier<Integer> sup) {
        return sup.get();
    }

    public static void main(String[] args) {
        int[] arr = {2, 8, 4, 10, 9, 0};

        // 调用 getMax 方法,参数传递 Lambda
        int maxNum = getMax(arr, () -> {
            int max = arr[0];

            for (int i : arr) {
                if (max < i) {
                    max = i;
                }
            }
            return max;
        });
        System.out.println(maxNum);
    }
}

Supplier<T>接口指定为 Integer,那么 get( ) 方法的返回值也只能为 Integer。试图返回其他类型的数据时,编译器无法通过编译。总的来说Supplier<T>接口是要啥给啥(根据泛型返回一个数据)


1.2 Consumer 接口

java.util.function.Consumer<T>接口则正好与 Supplier 接口相反,它不是生产一个数据,而是消费一个数据,其数据类型由泛型决定 。Consumer 接口中包含抽象方法void accept(T t),意为消费一 个指定泛型的数据。

1.2.1 示例代码

public class Demo {
    public static void show(Consumer<String> consumer) {
        consumer.accept("我是消费者");
    }

    public static void main(String[] args) {
        show(str -> System.out.println(str + "№.1"));
    }
}

1.2.2 andThen( ) 方法

  如果一个方法的参数和返回值全都是 Consumer 类型,那么就可以实现效果:消费数据的时候,首先做一个操作,然后再做一个操作,实现组合。而这个方法就是 Consumer 接口中的 default 方法 andThen。

andThen 源码

default Consumer<T> andThen(Consumer<? super T> after){
	Objects. requireNonNu11(after); 
	return (T t) -> { accept(t); after.accept(t);
};

示例代码

public class Demo {
    public static void show(Consumer<String> consumer1, Consumer<String> consumer2) {
        consumer1.andThen(consumer2).accept("我是消费者");
    }

    public static void main(String[] args) {
        show(str -> System.out.println(str + "№.1"), str -> System.out.println(str + "№.2"));
    }
}

进行组合消费时,谁在前先消费谁。


1.3 Predicate 接口

java.util.function.Predicate<T>接口可以对某种类型的数据进行判断,从而得到一个 boolean 值结果。Predicate 接口中包含一个抽象方法:boolean test(T t)用来对指定数据类型数据进行判断的方法,结果:符合返回 true,不符合返回 false

1.3.1 示例代码

public class Demo {
    public static boolean show(int num, Predicate<Integer> predicate) {
        return predicate.test(num);
    }

    public static void main(String[] args) {
        boolean show = show(5, (num) -> num > 3);
        System.out.println(show);
    }
}

1.3.2 默认方法

  既然是条件判断,就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时,可以使用默认方法 and。实现逻辑关系中的“或”,可以使用默认方法or。实现逻辑关系中的“非”,可以使用默认方法 negate。

and 源代码

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) ‐> test(t) && other.test(t);
}

or 源代码

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) ‐> test(t) || other.test(t);
}

negate 源代码

default Predicate<T> negate() {
    return (t) ‐> !test(t);
}

and、or、negate 方法都要在 test( ) 方法之前。

示例代码

public class Demo {
    public static boolean show(int num, Predicate<Integer> predicate1, Predicate<Integer> predicate2) {
        return predicate1.and(predicate2).negate().test(num);
    }

    public static void main(String[] args) {
        boolean show = show(5, (num) -> num > 3, (num) -> num < 10);
        System.out.println(show);
    }
}

1.4 Function 接口

java.uti1.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据,前者称为前置条件,后者称为后置条件。Function 接口中最主要的抽象方法为:Rapply(T t)根据类型 T 的参数获取类型 R 的结果。

public class Demo {
    public static Integer show(String str, Function<String, Integer> function) {
        return function.apply(str);
    }

    public static void main(String[] args) {
        Integer show = show("12315", (str) -> Integer.parseInt(str));
        System.out.println(show instanceof Integer);
    }
}