【Java】24 常用函数式接口

Myth丶恋晨 2023-02-09 13:17 120阅读 0赞

> 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>`接口是要啥给啥(根据泛型返回一个数据)  
![在这里插入图片描述][20200518235745117.png]

--------------------

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

![在这里插入图片描述][20200519000717429.png]

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

进行组合消费时，谁在前先消费谁。  
![在这里插入图片描述][20200519001500405.png]

--------------------

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

![在这里插入图片描述][20200519004034276.png]

[20200518235745117.png]: https://img-blog.csdnimg.cn/20200518235745117.png
[20200519000717429.png]: https://img-blog.csdnimg.cn/20200519000717429.png
[20200519001500405.png]: https://img-blog.csdnimg.cn/20200519001500405.png
[20200519004034276.png]: https://img-blog.csdnimg.cn/20200519004034276.png