一口气学会常见java函数式接口用法

引言

java函数式虽然日常使用特别方便，但是在阅读框架源码的时候，遇到函数式编程的写法可读性比较低，导致阅读障碍，现在将所有常见的函数式作用和写法总结了下，防止日后忘记。

口诀

1.Consumer：单输入无返回
2.BiConsumer：双输入无返回（Binary：二元的）
3.Function：单结果单输入
4.BiFunction：单结果双输入
5.Predicate：单布尔结果单输入
5.BiPredicate：单布尔结果双输入
6.Supplier：只返回无输入

详细说明和用法

1. Consumer: 用于执行对单个输入参数的操作，不返回任何结果。

   Consumer<String> consumer = (String s) -> System.out.println(s);
   consumer.accept("Hello, World!");  // 输出: Hello, World!
   

2. BiConsumer<T, U>: 用于执行对两个输入参数的操作，不返回任何结果。

   BiConsumer<String, Integer> biConsumer = (String s, Integer i) -> System.out.println(s + ": " + i);
   biConsumer.accept("Count", 10);  // 输出: Count: 10
   

3. Function<T, R>: 接收一个参数，返回一个结果。

   Function<Integer, String> function = i -> "Number is: " + i;
   String result = function.apply(5);  // result = "Number is: 5"
   System.out.println(result);
   

4. BiFunction<T, U, R>: 接收两个参数，返回一个结果。

   BiFunction<Integer, Integer, Integer> biFunction = (a, b) -> a + b;
   Integer sum = biFunction.apply(5, 10);  // sum = 15
   System.out.println(sum);
   

5. Predicate: 接收一个参数，返回一个布尔值。

   Predicate<Integer> predicate = i -> i > 0;
   boolean test = predicate.test(-1);  // test = false
   System.out.println(test);
   

6. BiPredicate<T, U>: 接收两个参数，返回一个布尔值。

   BiPredicate<Integer, Double> biPredicate = (i, d) -> i > d.intValue();
   boolean test = biPredicate.test(5, 4.9);  // test = true
   System.out.println(test);
   

7. UnaryOperator: 一个特化的 Function，其输入和输出类型相同。

   UnaryOperator<Integer> unaryOperator = i -> i * i;
   Integer square = unaryOperator.apply(4);  // square = 16
   System.out.println(square);
   

8. BinaryOperator: 一个特化的 BiFunction，其输入和输出类型相同。

   BinaryOperator<Integer> binaryOperator = (a, b) -> a * b;
   Integer product = binaryOperator.apply(6, 7);  // product = 42
   System.out.println(product);
   

9. Supplier: 不接收任何参数，返回一个结果。

   Supplier<String> supplier = () -> "Supplied value";
   String value = supplier.get();  // value = "Supplied value"
   System.out.println(value);
   

10. IntConsumer: 接收一个 int 类型的参数，执行操作但不返回任何结果。

    IntConsumer intConsumer = i -> System.out.println("IntConsumer: " + i);
    intConsumer.accept(100);  // 输出: IntConsumer: 100
    

11. LongConsumer: 接收一个 long 类型的参数，执行操作但不返回任何结果。

    LongConsumer longConsumer = l -> System.out.println("LongConsumer: " + l);
    longConsumer.accept(1000L);  // 输出: LongConsumer: 1000
    

12. DoubleConsumer: 接收一个 double 类型的参数，执行操作但不返回任何结果。

    DoubleConsumer doubleConsumer = d -> System.out.println("DoubleConsumer: " + d);
    doubleConsumer.accept(3.14);  // 输出: DoubleConsumer: 3.14
    

13. IntFunction: 接收一个 int 类型的参数，返回一个结果。

    IntFunction<String> intFunction = i -> "Value: " + i;
    String result = intFunction.apply(10);  // result = "Value: 10"
    System.out.println(result);
    

14. LongFunction: 接收一个 long 类型的参数，返回一个结果。

    LongFunction<String> longFunction = l -> "LongValue: " + l;
    String result = longFunction.apply(1000L);  // result = "LongValue: 1000"
    System.out.println(result);
    

15. DoubleFunction: 接收一个 double 类型的参数，返回一个结果。

    DoubleFunction<String> doubleFunction = d -> "DoubleValue: " + d;
    String result = doubleFunction.apply(2.718);  // result = "DoubleValue: 2.718"
    System.out.println(result);
    

16. ToIntBiFunction<T, U>: 接收两个参数，返回一个 int 类型的数值。

    ToIntBiFunction<Integer, Integer> toIntBiFunction = (a, b) -> a - b;
    int difference = toIntBiFunction.applyAsInt(20, 5);  // difference = 15
    System.out.println(difference);
    

17. ToLongBiFunction<T, U>: 接收两个参数，返回一个 long 类型的数值。

    ToLongBiFunction<Integer, Integer> toLongBiFunction = (a, b) -> (long) a / b;
    long result = toLongBiFunction.applyAsLong(10, 5);  // result = 2
    System.out.println(result);
    

18. ToDoubleBiFunction<T, U>: 接收两个参数，返回一个 double 类型的数值。

    ToDoubleBiFunction<Integer, Integer> toDoubleBiFunction = (a, b) -> (double) a / b;
    double result = toDoubleBiFunction.applyAsDouble(7, 2);  // result = 3.5
    System.out.println(result);
    

这些代码示例展示了如何声明函数式接口的实例，并使用Lambda表达式或方法引用来提供具体的操作。