Java8 函数式接口

概述

Runnable 执行一个没有参数和返回值的操作

@FunctionalInterface
public interface Runnable {
 public abstract void run();
}

Supplier 提供一个 T 类型的值

@FunctionalInterface
public interface Supplier<T> {
 /**
 * Gets a result.
 *
 * @return a result
 */
 T get();
}

Consumer 处理一个T类型的值

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

BiConsumer<T, U> 处理T类型和U类型

@FunctionalInterface
public interface BiConsumer<T, U> {
 void accept(T t, U u);
 default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> after) {
 Objects.requireNonNull(after);
 return (l, r) -> {
 accept(l, r);
 after.accept(l, r);
 };
 }

Function<T, R> 接收一个参数为T 的函数,返回类型为R

@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));
 }
 /**
 * 返回一个函数,返回值为传入的参数.
 */
 static <T> Function<T, T> identity() {
 return t -> t;
 }
}

BiFunction<T, U, R> 接受两个参数,返回 R类型

@FunctionalInterface
public interface BiFunction<T, U, R> {
 /**
 * 接受两个参数,返回 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));
 }
}

UnaryOperator

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {
 /**
 * 返回输入参数.
 */
 static <T> UnaryOperator<T> identity() {
 return t -> t;
 }
}

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

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);
 }
 /**
 * 返回一个谓词判定是否相等
 */
 static <T> Predicate<T> isEqual(Object targetRef) {
 return (null == targetRef)
 ? Objects::isNull
 : object -> targetRef.equals(object);
 }
}

BiPredicate<T, U>

@FunctionalInterface
public interface BiPredicate<T, U> {
 /**
 * 使用两个参数计算结果
 */
 boolean test(T t, U u);
 /**
 * 返回组合谓词,与 关系
 */
 default BiPredicate<T, U> and(BiPredicate<? super T, ? super U> other) {
 Objects.requireNonNull(other);
 return (T t, U u) -> test(t, u) && other.test(t, u);
 }
 /**
 * 返回否定的结果
 */
 default BiPredicate<T, U> negate() {
 return (T t, U u) -> !test(t, u);
 }
 /**
 * 返回【或】的结果
 */
 default BiPredicate<T, U> or(BiPredicate<? super T, ? super U> other) {
 Objects.requireNonNull(other);
 return (T t, U u) -> test(t, u) || other.test(t, u);
 }
}