一、接口大白话
1.四大基础接口
Consumer<T> - 核心方法：void accept(T t);
- 消费者。接受一个输入参数，不返回任何结果的操作。
- 望文生义：你给我啥，我就执行啥，没有结果。
Supplier<T> - 核心方法: T get();
- 供应商。生成一个指定类型的对象，方法没有参数。
- 望文生义：我也不跟你要，我有啥就给你啥。
Function<T, R> - 核心方法：R apply(T t);
- 函数。接受一个输入参数，返回一个结果。
- 望文生义：你想要什么，你就得把原料和加工方法告诉我。
Predicate<T> - 核心方法：boolean test(T t);
- 断言。接受一个输入参数，返回一个布尔值结果。
- 望文生义：是对是错总有一个，事儿你告诉我，我负责出结果。
2. 子接口和派生接口
2.1 Consumer
派生接口：
BiConsumer<T, U> - 接口说明：接受两个输入参数并且没有返回结果的操作。
- 核心方法：void accept(T t, U u);
2.2 Function
子接口：
UnaryOperator<T> - 接口说明：接受两个输入参数并且没有返回结果的操作。
- 核心方法：void accept(T t, U u);
派生接口：
IntFunction<R> - 接口说明：接受一个 int 类型的输入参数，并返回一个指定类型的结果。
- 核心方法：R apply(int value)。
IntUnaryOperator - 接口说明：接受一个 int 类型的参数并且返回同一类型的结果。
- 核心方法：int applyAsInt(int operand)。
ToDoubleFunction<T> - 接口说明：接受一个输入参数，并返回一个 double 类型的结果。
- 核心方法：double applyAsDouble(T value)。
ToLongFunction<T> - 接口说明：接受一个输入参数，并返回一个 long 类型的结果。
- 核心方法： long applyAsLong(T value)。
ToIntFunction<T> - 接口说明：接受一个输入参数，并返回一个 int 类型的结果。
- 核心方法：int applyAsInt(T value)。
BiFunction<T, U, R> - 接口说明：接受两个输入参数并且返回结果。
- 核心方法：R apply(T t, U u)。
- 子接口：
BinaryOperator<T> - 接口说明：接受两个同类型的参数并且返回同一类型的结果。
- 核心方法：T apply(T t1, T t2)。
- 派生接口：
IntBinaryOperator - 接口说明：接受两个同类型的 int 类型参数并且返回同一类型的结果。
- 核心方法：int applyAsInt(int left, int right)。
2.3 Predicate
派生接口：
IntPredicate - 接口说明：接受一个 int 类型的参数，返回一个布尔值结果。
- 核心方法： boolean test(int value)。
二、基础接口源码：
1. Consumer
package java.util.function;
import java.util.Objects;@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); };}
}
2. Supplier
package java.util.function;
@FunctionalInterface
public interface Supplier<T> {T get();
}
3. Predicate
package java.util.function;import java.util.Objects;
@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);}
}
4. Function
package java.util.function;import java.util.Objects;
@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;}
}
