Java 8 Functional Interfaces

Introduction

在 Java 8 中，函数式接口是一个只有一个抽象方法的接口。函数式接口可以使用 Lambda 表达式来创建实例，从而简化了代码编写。Java 8 提供了 @FunctionalInterface 注解来标识函数式接口，以便编译器检查该接口是否符合函数式接口的定义。

函数式接口通常用在集合框架中和 Stream 流中。

@FunctionalInterface
public interface MyFunctionalInterface {
    void myMethod(); // 唯一的抽象方法

    // 可以有默认方法、静态方法和 Object 类中的方法（equals、hashCode、toString）
    default void defaultMethod() {
        System.out.println("Default method");
    }

    static void staticMethod() {
        System.out.println("Static method");
    }
}

Supplier

一种通用的返回结果的 Supplier，抽象方法是 T get()。

@FunctionalInterface
public interface Supplier<T> {

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

public class Person {
  String firstName;
  String lastName;

  public Person() {

  }

  public Person(String firstName, String lastName) {
    this.firstName = firstName;\
    this.lastName = lastName;
  }

  // getters and setters
}

Supplier<Person> personSupplier = Person::new;
Person person = personSupplier.get();

Specializations of Supplier

• IntSupplier：返回 int 值的 Supplier。
• LongSupplier：返回 long 值的 Supplier。
• DoubleSupplier：返回 double 值的 Supplier。
• BooleanSuppiler：返回 boolean 值的 Supplier。

Consumer

表示接收一个输入参数并且不返回结果的操作。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Specializations of Consumers

• IntConsumer：表示一个接收 单个 int 值不返回结果的操作。
• DoubleConsumer：表示一个接收 单个 double 值不返回结果的操作。
• LongConsumer：表示一个接收 单个 long 值不返回结果的操作。
• ObjIntConsumer：表示一个接收一个对象值和一个 int 值不返回结果的操作。
• ObjDoubleConsumer：表示一个接收一个对象值和一个 double 值不返回结果的操作。
• ObjLongConsumer：表示一个接收一个对象值和一个 long 值不返回结果的操作。
• BiConsumer：表示一个接收两个输入参数（泛型参数）不返回结果的操作。

Predicate

表示基于一个参数（泛型参数）的 Predicate。

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
}

Predicate<String> predicate = str -> str.length() > 0;
predicate.test("Hello World");
predicate.negate().test("foo");

Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();

Specializations of Predicate

• IntPredicate：表示一个基于 int 值的 Predicate。
• LongPredicate：表示一个基于 long 值的 Predicate。
• DoublePredicate：表示一个基于 double 值的 Predicate。
• BiPredicate：表示一个基于两个参数的 Predicate。

Function

表示一个接收一个参数并产生一个结果的函数，Function 函数式接口用来做 Stream 流处理 filter-map-reduce 中的 Map 类型转换。

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
}