【Java】24 常用函数式接口

Demo_Null

发布于 2020-09-28 11:10:28

3780

发布于 2020-09-28 11:10:28

文章被收录于专栏：Java 学习

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);
    }
}