Java 函数式编程 - 函数式接口 函数式接口在 Java 中是指：有且仅有一个抽象方法的接口。 函数式接口可以被隐式转换为 Lambda 表达式。

Java 函数式编程 - 函数式接口

概念

函数式接口在 Java 中是指：有且仅有一个抽象方法的接口

函数式接口可以被隐式转换为 Lambda 表达式。

@FunctionalInterface

@FunctionalInterface // 标明为函数式接口
public interface MyFunctionInterface {
    void mrthod(); //抽象方法
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。(该接口是一个标记接口)

常用的函数式接口

Supplier 接口

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

用来返回一个值，即供应器

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); };
    }
}

用来消费一个值，即消费器

默认方法

  • andThen：组合多个 consumer，可以实现消费数据的时候，首先做一个操作，然后再做一个操作
Consumer<Integer> consumer = ((Consumer<Integer>) i -> System.out.println("a" + i))
    .andThen(i -> System.out.println("b" + i));

Stream.of(1, 2, 3, 4).forEach(consumer);
// 输出：a1 b1 a2 b2 a3 b3 a4 b4

Predicate 接口

@FunctionalInterface
public interface Predicate<T> {

    boolean test(T t);

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

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

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

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

用来判断一个值是否符合条件，即判断器

默认方法

  • negate：取反
  • and：类似于 &&
  • or：类似于 ||

静态方法

  • isEqual：返回一个输入值是否等于目标值的 Predicate 接口

Function 接口

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

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

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

用来将一个值转换成其它类型的值，即转换器

默认方法

  • andThen：组合多个 function，可以实现先做一个转换，再做一个转换
Function<Integer, Integer> mapper = ((Function<Integer, Integer>) i -> i * 10)
    .andThen(i -> i - 1);

Stream.of(1, 2, 3, 4)
    .map(mapper)
    .forEach(System.out::println);
// 输出：9 19 29 39
  • compose：也是组合多个 function，不过组合顺序跟 andThen 相反
Function<Integer, Integer> mapper = ((Function<Integer, Integer>) i -> i * 10)
    .compose(i -> i - 1);

Stream.of(1, 2, 3, 4)
    .map(mapper)
    .forEach(System.out::println);
// 输出：0 10 20 30

静态方法

identity：不做转换，原样返回输入值

UnaryOperator 接口

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

[[#Function 接口]]的特例，转换前和转换后的类型不变

BiFunction 接口

@FunctionalInterface
public interface BiFunction<T, U, R> {

    R apply(T t, U u);

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

[[#Function 接口]]的另一个版本，接收两个值并返回一个新值

BinaryOperator 接口

@FunctionalInterface
public interface BinaryOperator<T> extends BiFunction<T,T,T> {

    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
    }

    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
        Objects.requireNonNull(comparator);
        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
    }
}

[[#BiFunction 接口]]的特例，转换前和转换后的类型不变

Java8 新增的函数式接口

Supplier

接口

描述

Supplier<T>

无参数，返回一个结果

BooleanSupplier

代表了 boolean 值结果的提供方

IntSupplier

无参数，返回一个 int 类型结果

LongSupplier

无参数，返回一个结果 long 类型的值

DoubleSupplier

代表一个 double 值结构的提供方

Consumer

接口

描述

Consumer<T>

代表了接受一个输入参数并且无返回的操作

IntConsumer

接受一个 int 类型的输入参数，无返回值

LongConsumer

接受一个 long 类型的输入参数，无返回值

DoubleConsumer

代表一个接受 double 值参数的操作，并且不返回结果

ObjIntConsumer<T>

接受一个 object 类型和一个 int 类型的输入参数，无返回值

BiConsumer<T,U>

代表了一个接受两个输入参数的操作，并且不返回任何结果

ObjLongConsumer<T>

接受一个 object 类型和一个 long 类型的输入参数，无返回值

ObjDoubleConsumer<T>

接受一个 object 类型和一个 double 类型的输入参数，无返回值

Predicate

接口

描述

Predicate<T>

接受一个输入参数，返回一个布尔值结果

IntPredicate

接受一个 int 输入参数，返回一个布尔值的结果

LongPredicate

接受一个 long 输入参数，返回一个布尔值类型结果

DoublePredicate

代表一个拥有 double 值参数的 boolean 值方法

BiPredicate<T,U>

代表了一个两个参数的 boolean 值方法

Function

接口

描述

Function<T,R>

接受一个输入参数，返回一个结果

IntFunction<R>

接受一个 int 类型输入参数，返回一个结果

IntToLongFunction

接受一个 int 类型输入，返回一个 long 类型结果

IntToDoubleFunction

接受一个 int 类型输入，返回一个 double 类型结果

LongFunction<R>

接受一个 long 类型输入参数，返回一个结果

LongToIntFunction

接受一个 long 类型输入，返回一个 int 类型结果

LongToDoubleFunction

接受一个 long 类型输入，返回一个 double 类型结果

DoubleFunction<R>

代表接受一个 double 值参数的方法，并且返回结果

DoubleToIntFunction

接受一个 double 类型输入，返回一个 int 类型结果

DoubleToLongFunction

接受一个 double 类型输入，返回一个 long 类型结果

ToIntFunction<T>

接受一个输入参数，返回一个 int 类型结果

ToLongFunction<T>

接受一个输入参数，返回一个 long 类型结果

ToDoubleFunction<T>

接受一个输入参数，返回一个 double 类型结果

UnaryOperator

接口

描述

UnaryOperator<T>

接受一个参数为类型 T,返回值类型也为 T

IntUnaryOperator

接受一个参数同为类型 int,返回值类型也为 int

LongUnaryOperator

接受一个参数同为类型 long,返回值类型也为 long

DoubleUnaryOperator

接受一个参数同为类型 double,返回值类型也为 double

BiFunction

接口

描述

BiFunction<T,U,R>

代表了一个接受两个输入参数的方法，并且返回一个结果

ToIntBiFunction<T,U>

接受两个输入参数，返回一个 int 类型结果

ToLongBiFunction<T,U>

接受两个输入参数，返回一个 long 类型结果

ToDoubleBiFunction<T,U>

接受两个输入参数，返回一个 double 类型结果

BinaryOperator

接口

描述

BinaryOperator<T>

代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果

IntBinaryOperator

接受两个参数同为类型 int,返回值类型也为 int

LongBinaryOperator

接受两个参数同为类型 long,返回值类型也为 long

DoubleBinaryOperator

代表了作用于两个 double 值操作符的操作，并且返回了一个 double 值的结果