最近java.util.function包用到的比较频繁，感觉很好用。系统整理一下，帮助快速回忆

结构总览

function包中的接口可以大致分为以下几种，根据接口名称也可以看出来：

• function
• predicate
• supplier
• consumer
• operator

1.function

• 代表一个函数，接收一个参数，返回一个参数。虽然一个function结构和功能较为单一，但可以通过多个function的组装完成复杂功能。（不禁联想FaaS）
• 提供了compose andThen identity对function进行再处理的入口
• BiFunction二元函数，相较于Function接口，可接收两参并返回

public class FunctionTest {@Testpublic void test() {// int 转 strFunction<Integer, String> int2Str = String::valueOf;// 平方Function<String, Integer> square = e -> {int i = Integer.parseInt(e);return i * i;};// 格式输出Function<String, Date> format = e -> new Date();String apply = int2Str.apply(5);// note: apply 实际传入的参数类型取决于compose,这里前置函数需要String类型,所以传入"5"// note: andThen 的函数入参必须是apply的return类型Date apply2 = int2Str.compose(square) // 前置处理: apply执行前,先计算平方.andThen(format) // 后置处理: apply执行后,格式化输出.apply("5"); // 处理System.out.println(apply);System.out.println(apply2); //}// 标记占位，用于拓展@Testpublic void test2() {List<String> names = List.of("Alice", "Bob", "Charlie");// note 定义可扩展的方法,处理逻辑动态传入. 使用Function.identity()进行占位List<String> processedNames = processList(names, Function.identity());System.out.println(processedNames); // 输出: [Alice, Bob, Charlie]}public static <T> List<T> processList(List<T> list, Function<T, T> processor) {List<T> result = new ArrayList<>();for (T item : list) {result.add(processor.apply(item)); // 应用处理函数}return result;}
}

2.predicate

• 定义判断的函数
• 如function一样，内部提供了 and or negate,即 与 或 非 逻辑，可以将多个判断进行组装
• 提供了isEqual not静态工具，可快速返回指定predicate对象

@Test
public void predicate(){// 定义一个predicate：是否是偶数Predicate<Integer> even = integer -> integer % 2 == 0;Assert.assertTrue("input not a even", even.test(6));// and 与上另一个predicate: 输入为偶数 且 大于5Predicate<Integer> and = even.and(input -> input > 5);Assert.assertTrue("input <= 5", and.test(6));// or 或上另一个predicate: 输入为偶数 或 大于10Predicate<Integer> or = even.or(input -> input > 10);Assert.assertTrue("input >= 10", or.test(6));// 取反: 是奇数Predicate<Integer> odd = even.negate();Assert.assertTrue("input not a odd", odd.test(7));// 静态函数：返回当前predicate的取反，内部调用的还是 negatePredicate<Integer> not = Predicate.not(even);Assert.assertTrue("input not a odd", not.test(7));// 静态函数： isEqual 返回一个predicatePredicate<String> equalMsg = Predicate.isEqual("msg");Assert.assertTrue(equalMsg.test("msg1"));
}

3.supplier

• 通过supplier定义数据来源，使用get返回数据
• XxSupplier对Supplier接口进行了细化，功能类似

// supplier: 定义数据提供者
@Test
public void supplier(){Supplier<List<String>> supplier = () -> {List<String> list = new ArrayList<>();list.add("a");list.add("b");return list;};List<String> result = supplier.get();System.out.println(result);// XxSupplier   getAsXx}

4.consumer

• Consumer<T>定义单参消费者，仅对入参进行消费处理，不返回
• BiConsumer<T, U>二元消费者，允许两个入参

@Test
public void biConsumer(){BiConsumer<String, String> biConsumer = (s, s2) -> System.out.println(s + " : " + s2);biConsumer.accept("a", "b");
} 

5.operator

具体的某种操作，可看做是对Function的细化，比如：元操作
UnaryOperator<T> extends Function<T, T>; 再比如其他具体到数据类型的操作，如IntUnaryOperator LongUnaryOperator等。