上海知名网站建设公司北京竞价托管代运营

一、接口大白话

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

/** 该代码定义了一个函数式接口 Consumer，它表示一个接受单个输入参数并且不返回结果的操作。* Consumer 接口的主要方法是 accept，允许执行具有副作用的操作。* 此外，接口还提供了 andThen 方法，用于将两个 Consumer 操作串联在一起，使得在执行第一个操作后可以执行第二个操作。* 如果在执行任何操作时抛出异常，异常将被传递给调用者。* * @param <T> 输入操作的类型*/
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;/** 该代码定义了一个函数式接口 Supplier，表示结果的供应者。* 该接口包含一个方法 get()，用于获取结果。Supplier 接口的实现可以返回一个类型为 T 的结果。* 该接口没有要求每次调用时返回新的或不同的结果。它是 Java 1.8 引入的。*/
@FunctionalInterface
public interface Supplier<T> {T get();
}

3. Predicate

/** 该代码定义了一个函数式接口 Predicate，表示一个接受一个参数并返回布尔值的函数。* 该接口包含一个测试方法 test(T t)，以及用于组合多个谓词的默认方法 and、negate 和 or。* 还提供了一个静态方法 isEqual，用于创建一个谓词，该谓词测试两个参数是否相等。* 该接口是 Java 8 引入的，位于 java.util.function 包中。*/
package java.util.function;import java.util.Objects;/*** 表示一个一元谓词（布尔值函数）。** <p>这是一个功能接口，其功能方法是{@link #test(Object)}。** @param <T> 谓词的输入类型** @since 1.8*/
@FunctionalInterface
public interface Predicate<T> {/*** 使用给定的参数评估此谓词。** @param t 输入参数* @return 如果输入参数符合谓词条件，则返回{@code true}，否则返回{@code false}*/boolean test(T t);/*** 返回一个组合谓词，代表此谓词和另一个谓词的短路逻辑与。* 当评估组合谓词时，如果此谓词为{@code false}，则不会评估{@code other}谓词。** <p>评估任一谓词时抛出的任何异常都会被传递给调用者；* 如果评估此谓词时抛出异常，则不会评估{@code other}谓词。** @param other 将与此谓词进行逻辑与的谓词* @return 一个组合谓词，代表此谓词和{@code other}谓词的短路逻辑与* @throws NullPointerException 如果other为null*/default Predicate<T> and(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) && other.test(t);}/*** 返回一个谓词，表示此谓词的逻辑非。** @return 表示此谓词逻辑非的谓词*/default Predicate<T> negate() {return (t) -> !test(t);}/*** 返回一个组合谓词，代表此谓词和另一个谓词的短路逻辑或。* 当评估组合谓词时，如果此谓词为{@code true}，则不会评估{@code other}谓词。** <p>评估任一谓词时抛出的任何异常都会被传递给调用者；* 如果评估此谓词时抛出异常，则不会评估{@code other}谓词。** @param other 将与此谓词进行逻辑或的谓词* @return 一个组合谓词，代表此谓词和{@code other}谓词的短路逻辑或* @throws NullPointerException 如果other为null*/default Predicate<T> or(Predicate<? super T> other) {Objects.requireNonNull(other);return (t) -> test(t) || other.test(t);}/*** 返回一个谓词，测试两个参数是否根据{@link Objects#equals(Object, Object)}相等。** @param <T> 谓词的参数类型* @param targetRef 用于比较相等的对象引用，可以为{@code null}* @return 一个谓词，测试两个参数是否根据{@link Objects#equals(Object, Object)}相等*/static <T> Predicate<T> isEqual(Object targetRef) {return (null == targetRef)? Objects::isNull: object -> targetRef.equals(object);}
}

4. Function

/** 此代码定义了一个函数式接口 Function，表示接受一个参数并产生一个结果的函数。* 该接口包含一个抽象方法 apply，允许实现类定义函数的具体行为。* 还提供了 compose 和 andThen 方法，用于函数的组合，允许在函数调用前后应用其他函数。* 此外，提供了一个静态方法 identity，返回一个始终返回其输入参数的函数。* 该接口是 Java 8 引入的，属于 java.util.function 包。*/
package java.util.function;import java.util.Objects;/*** 代表接受一个参数并生成结果的函数。** 该接口是一个函数式接口，其函数方法是{@link #apply(Object)}。** @param <T> 函数输入的类型* @param <R> 函数结果的类型** @since 1.8*/
@FunctionalInterface
public interface Function<T, R> {/*** 将此函数应用于给定参数。** @param t 函数参数* @return 函数结果*/R apply(T t);/*** 返回一个复合函数，首先将输入应用于{@code before}函数，然后将此函数应用于结果。* 如果任一函数的评估抛出异常，它将被传递给复合函数的调用者。** @param <V> {@code before}函数和复合函数的输入类型* @param before 在应用此函数之前应用的函数* @return 一个复合函数，首先应用{@code before}函数，然后应用此函数* @throws NullPointerException 如果before为null** @see #andThen(Function)*/default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));}/*** 返回一个复合函数，首先将此函数应用于输入，然后将结果应用于{@code after}函数。* 如果任一函数的评估抛出异常，它将被传递给复合函数的调用者。** @param <V> {@code after}函数和复合函数的输出类型* @param after 在应用此函数之后应用的函数* @return 一个复合函数，首先应用此函数，然后应用{@code after}函数* @throws NullPointerException 如果after为null** @see #compose(Function)*/default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}/*** 返回一个总是返回其输入参数的函数。** @param <T> 函数的输入和输出对象的类型* @return 一个总是返回其输入参数的函数*/static <T> Function<T, T> identity() {return t -> t;}
}