Gang

2022-04-22 约 400 字预计阅读 2 分钟

JDK自带的函数接口

位置：java.util.function.BiConsumer

test1

接口分类

消费型

Consumer<T>
1

void accept(T t);

BiConsumer<T, U>

1

void accept(T t, U u);   // 增加一种入参类型

供给型

Supplier<T>

1
2
3
4
5
6


/**
 * Gets a result.
 *
 * @return a result
 */
T get();

函数型

Function<T, R>
UnaryOperator<T>
BiFunction<T, U, R>
BinaryOperator<T>
ToIntFunction<T>
ToLongFunction<T>
ToDoubleFunction
IntFunction<R>
LongFunction<R>
DoubleFunction<R>

断言型

Predicate<T>

1
2
3
4
5
6
7
8


/**
  * Evaluates this predicate on the given argument.
  *
  * @param t the input argument
  * @return {@code true} if the input argument matches the predicate,
  * otherwise {@code false}
  */
boolean test(T t);

方法引入

静态方法引入

类名::(静态)方法名称
对象方法引入

类名::实例方法名称
实例方法引入
```
1. new 对象
1. 对象::方法名称
```
构造函数引入

类名::new

方法引入的方法参数列表、返回类型必须要与函数接口的参数列表和返回值保持一致

静态方法引入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


@FunctionalInterface
public interface MyFunctionalInterface {
  void get();
  default void add(){}
  String toString();
}

public class Test10 {
  public static void main(String[] args) {
    MyFunctionalInterface myFunctionalInterface = new MyFunctionalInterface() {
      @Override
      public void get() {
        System.out.println("get() method");
      }
    };

    myFunctionalInterface.get();

    // 静态方法引入
    MyFunctionalInterface myFunctionalInterface1 = Test10::staticGet;
    myFunctionalInterface1.get();
  }

  // 该方法的参数和返回类型和MyFunctionalInterface函数接口的参数列表和返回类型是一致的
  public static void staticGet() {
    System.out.println("static get method");
  }
}

对象方法引入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


public class Test14 {
  public static void main(String[] args) {
    MyFunctionalInterface04 myFunctionalInterface04 = new MyFunctionalInterface04() {
      @Override
      public String get(Test14 test14) {
        return test14.objGet();
      }
    };

    System.out.println(myFunctionalInterface04.get(new Test14()));

    // lambda 表达式监护
    myFunctionalInterface04 = test14 -> test14.objGet();
    System.out.println(myFunctionalInterface04.get(new Test14()));

    // 对象构造方法引入
    // 以往情况下由于objGet方法并不是static方法不能使用Test14::objGet方式
    // 但是由于函数接口中的get方法需要传入一个new Test14() 对象
    // 直接简化成了Test14::objGet方式
    myFunctionalInterface04 = Test14::objGet;
    System.out.println(myFunctionalInterface04.get(new Test14()));
  }

  public String objGet(){
    return "object get method exec.";
  }
}

实例方法引入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


public class Test12 {
  public static void main(String[] args) {
    Test12 test12 = new Test12();
    MyFunctionalInterface02 myFunctionalInterface = () -> test12.objectGet();
    System.out.println(myFunctionalInterface.get());

    // lambda表达式写法
    MyFunctionalInterface02 myFunctionalInterface02 = test12::objectGet;
    System.out.println(myFunctionalInterface.get());
  }

  public String objectGet() {
    return "object get method.";
  }
}

构造函数方法引入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class Test13 {
  public static void main(String[] args) {
    MyFunctionalInterface03 myFunctionalInterface03 = () -> new MessageEntity();
    System.out.println(myFunctionalInterface03.get());

    // lambda 表达式
    MyFunctionalInterface03 myFunctionalInterface = MessageEntity::new;
    System.out.println(myFunctionalInterface.get());
  }
}

3.JDK自带的函数接口和方法引入

JDK自带的函数接口

接口分类

消费型

供给型

函数型

断言型

方法引入

静态方法引入

对象方法引入

实例方法引入

构造函数方法引入

相关内容