Java 函数接口 ( Functional interface )

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】

Java 8 引入了 「 函数接口 」 ( funtional interface ) 的概念,「 函数接口 」就是那些有且只有显式定义一个方法的接口。

例如,具有单个方法 compareTo() 的接口 Comparable 接口,它只有一个功能,就是用于比较。

这种函数接口一般用于 Java 8 中的 Lambda 表达式 。 而且 Java 8 为了支持 Lambda 表达式,更是定义了许多函数接口。这些接口基本都在 java.util.function 包中。

函数接口

函数接口为 Java 8 Lambda 表达式和方法引用提供目标类型。每个函数接口都有一个 虚 ( abstract ) 方法,成为该函数接口的函数方法。用于适配该类型的 Lambda 表达式的参数类型和返回值类型。

函数接口可以在多个上下文中提供目标类型,例如赋值上下文,方法调用或强制转换上下文。

我们写一小段代码演示下

    // Assignment context
    Predicate<String> p = String::isEmpty;

    // Method invocation context
    stream.filter(e -> e.getSize() > 10)...

    // Cast context
    stream.map((ToIntFunction) e -> e.getSize())..

函数接口的规则

那么,什么样的接口才能称之为函数接口呢 ?

如果一个接口的实现类只需要实现一个方法,那么该接口就是函数接口。

具体来说,有以下两种情况

  1. 那些只有一个方法的接口,例如 Comparable 接口,它只有一个方法 compareTo()
  2. 那些具有多个默认方法,但有且只有一个虚方法的接口。也就是说,函数接口也可以有多个方法,但除了一个可用 Lambda 表达式来实现的方法,其它方法都必须有 default 关键字。

java.util.function 包中定义的函数接口

java.util.function 包中定义了大量的函数接口,下表列出了这些接口,并对其做一些简单的介绍。

接口 说明
BiConsumer<T,U> 表示接受两个不同类型的参数,但不返回任何结果的操作
BiFunction<T,U,R> 表示接受两个不同类型的参数,并返回一个其它类型的结果的操作
BinaryOperator<T> 表示接受两个相同类型的参数,并返回一个同一类型的结果的操作
BiPredicate<T,U> 表示接受两个不同诶行的参数,且返回布尔类型的结果的操作
BooleanSupplier 不接受任何参数,且返回一个布尔类型的结果的操作
Consumer<T> 表示接受一个参数,但不返回任何结果的操作
DoubleBinaryOperator 表示接受两个double类型的参数,并返回double类型结果的操作
DoubleConsumer 表示接受一个double类型的参数,但不返回任何结果的操作
DoubleFunction<R> 表示接受一个double类型的参数,且返回一个R类型的结果的操作
DoublePredicate 表示一个接受两个double类型的参数,且返回一个布尔类型的结果的操作
DoubleSupplier 表示一个不接受任何参数,但返回布尔类型的结果的操作
DoubleToIntFunction 表示接受两个double类型的参数,但返回一个int类型的结果的操作
DoubleToLongFunction 表示接受两个double类型的参数,但返回一个long类型的结果的操作
DoubleUnaryOperator 表示接受一个double类型的参数,且返回一个double类型的结果的操作
Function<T,R> 表示一个接受T类型的参数,且返回一个R类型结果的函数
IntBinaryOperator 表示一个接受两个int类型的参数,且返回一个int类型的结果的操作
IntConsumer 表示接受一个int类型的参数,但不返回任何结果的操作
IntFunction<R> 表示接受一个int类型的参数,但返回一个R类型的结果的操作
IntPredicate 表示接受一个int类型的参数,但返回布尔类型的结果的操作
IntSupplier 表示不接受任何参数,但返回一个int类型的结果的操作
IntToDoubleFunction 表示接受一个int类型的参数,但返回一个double类型的结果的操作
IntToLongFunction 表示接受一个int类型的参数,但返回一个long类型的结果的操作
IntUnaryOperator 表示接受一个int类型的参数,且返回一个int类型的结果的操作
LongBinaryOperator 表示接受两个long类型的参数,且返回一个long类型的结果的操作
LongConsumer 表示不接受任何参数,但返回一个long类型的结果的操作
LongFunction<R> 表示接受一个loing类型的参数,但返回一个R类型的结果的操作
LongPredicate 表示接受一个long类型的参数,但返回布尔类型的结果的操作
LongSupplier 表示不接受任何参数,但返回一个long类型的结果的操作
LongToDoubleFunction 表示接受一个long类型的参数,但返回一个double类型的结果的函数
LongToIntFunction 表示接受一个long类型的参数,但返回int类型的结果的函数
LongUnaryOperator 表示接受一个long类型的参数,并返回一个long类型的结果的操作
ObjDoubleConsumer<T> 表示接受两个参数,一个为T类型的对象,另一个double类型,但不返回任何结果的操作
ObjIntConsumer<T> 表示接受两个参数,一个为T类型的对象,另一个int类型,但不返回任何结果的操作
ObjLongConsumer<T> 表示接受两个参数,一个为T类型的对象,另一个double类型,但不返回任何结果的操作
Predicate<T> 表示接受一个指定类型T的参数,但返回布尔类型的结果的操作
Supplier<T> 表示不接受任何参数,但返回一个T类型的结果的操作
ToDoubleBiFunction<T,U> 表示接受两个不同类型的参数,但返回一个double类型的结果的操作
ToDoubleFunction<T> 表示一个接受指定类型T的参数,并返回一个double类型的结果的操作
ToIntBiFunction<T,U> 表示接受两个不同类型的参数,但返回一个int类型的结果的操作
ToIntFunction<T> 表示一个接受指定类型T的参数,并返回一个int类型的结果的操作
ToLongBiFunction<T,U> 表示接受两个不同类型的参数,但返回一个long类型的结果的操作
ToLongFunction<T> 表示一个接受指定类型的参数,并返回一个long类型的结果的操作
UnaryOperator<T> 表示接受一个参数,并返回一个与参数类型相同的结果的操作

看起来很多接口功能都是重复的。但实际上并非如此,因为各个接口表面上看起来一样,但实际上它们有着不同的默认方法

范例

我们写一个范例来演示下 Predicate<T> 函数接口的使用。

Predicate<T> 只有一个虚方法 test(Object),该方法接受一个 T 类型的对象,然后返回布尔类型的结果。因此,我们的 Lambda 表达是的参数也是 T 类型,返回值则是布尔类型

Java8Tester.java

    import java.util.Arrays;
    import java.util.List;
    import java.util.function.Predicate;

    public class Java8Tester {

       public static void main(String args[]) {
          List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

          // Predicate<Integer> predicate = n -> true
          // n is passed as parameter to test method of Predicate interface
          // test method will always return true no matter what value n has.

          System.out.println("Print all numbers:");

          //pass n as parameter
          eval(list, n->true);

          // Predicate<Integer> predicate1 = n -> n%2 == 0
          // n is passed as parameter to test method of Predicate interface
          // test method will return true if n%2 comes to be zero

          System.out.println("Print even numbers:");
          eval(list, n-> n%2 == 0 );

          // Predicate<Integer> predicate2 = n -> n > 3
          // n is passed as parameter to test method of Predicate interface
          // test method will return true if n is greater than 3.

          System.out.println("Print numbers greater than 3:");
          eval(list, n-> n > 3 );
       }

       public static void eval(List<Integer> list, Predicate<Integer> predicate) {

          for(Integer n: list) {

             if(predicate.test(n)) {
                System.out.println(n + " ");
             }
          }
       }
    }

运行结果如下

    [yufei@www.twle.cn helloworld]$ javac Java8Tester.java && java Java8Tester
    Print all numbers:
    1 
    2 
    3 
    4 
    5 
    6 
    7 
    8 
    9 
    Print even numbers:
    2 
    4 
    6 
    8 
    Print numbers greater than 3:
    4 
    5 
    6 
    7 
    8 
    9

来源:https://www.twle.cn

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » Java 函数接口 ( Functional interface )

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏