Java中的函数式接口详解（二）

前言：

第一篇文章给大家带来了Function、Consumer函数式接口的方法讲解和演示。这篇文章接着给大家介绍Predicate和Supplier的方法使用详解。

4. Predicate 谓语接口

4.1. 分类

序号	接口	描述
1	Predicate<T>	对给定的输入参数执行操作，返回一个 boolean 类型的结果（布尔值函数）
2	BiPredicate<T,U>	对给定的两个输入参数执行操作，返回一个 boolean 类型的结果（布尔值函数）
3	DoublePredicate	对给定的double参数执行操作，返回一个 boolean 类型的结果（布尔值函数）
4	IntPredicate	对给定的int输入参数执行操作，返回一个 boolean 类型的结果（布尔值函数）
5	LongPredicate	对给定的long参数执行操作，返回一个 boolean 类型的结果（布尔值函数）

下面，博主将介绍几种常见Predicate函数的使用方法。

4.2. Predicate<T>

源码：

@FunctionalInterface
public interface Predicate<T> {

    /**
     * 根据给定的参数计算此谓词。
     *
     * @param t 输入参数
     * @return 如果输入参数与谓词匹配，则为true，否则为false
     */
    boolean test(T t);

    /**
     * 返回一个组合谓词，表示此谓词和另一个谓词的短路逻辑与。在评估组合谓词时，如果此谓词为假，则不会评估另一个谓词。
	 * 在评估任一谓词期间抛出的任何异常都会转发给调用者；如果对该谓词的求值抛出异常，则不会对另一个谓词求值。
     *
     * @param other 一个将与此谓词进行逻辑AND运算的谓词
     * @return 一个复合谓词，表示该谓词和另一个谓词的短路逻辑与
     * @throws NullPointerException
     */
    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);
    }

    /**
     * 返回一个组合谓词，表示此谓词和另一个谓词的短路逻辑OR。在计算组合谓词时，如果此谓词为真，则不计算另一个谓词。
	 * 在评估任一谓词期间抛出的任何异常都会转发给调用者；如果对该谓词的求值抛出异常，则不会对另一个谓词求值。
     *
     * @param 一个将与此谓词进行逻辑OR运算的谓词
     * @return 一个复合谓词，表示该谓词和另一个谓词的短路逻辑OR
     * @throws NullPointerException
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * 返回一个谓词，根据 Objects.equals(Object，Object) 测试两个参数是否相等。
     *
     * @param targetRef 用于比较相等性的对象引用，可以为null
     * @return 根据Objects. equals（Object，Object）测试两个参数是否相等的谓词
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

    /**
     * 返回一个谓词，该谓词是所提供谓词的否定。这是通过返回调用 target.negation() 的结果来实现的。
     *
     * @param target  否定谓词
     *
     * @return 否定所提供谓词结果的谓词
     *
     * @throws NullPointerException
     *
     * @since 11  JDK 11 后才有的新方法
     */
    @SuppressWarnings("unchecked")
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

方法：

接口方法	方法描述
boolean test(T t)	根据给定的参数进行判断
Predicate<T> and(Predicate<? super T> other)	返回一个组合判断，将 other 以短路与的方式加入到函数的判断中
Predicate<T> or(Predicate<? super T> other)	返回一个组合判断，将 other 以短路或的方式加入到函数的判断中
Predicate<T> negate()	将函数的判断取反
Predicate<T> isEqual(Object targetRef)	判断两个参数是否相等，需要配合 test() 来使用
Predicate<T> not(Predicate<? super T> target)	返回所提供 target 的取反结果

方法示例：

1. boolean test(T t)

Predicate<Integer> predicate = number -> number != 0;
System.out.println(predicate.test(10));    //true

1. Predicate<T> and(Predicate<? super T> other)

Predicate<Integer> predicate = number -> number != 0;
predicate = predicate.and(number -> number >= 10);
System.out.println(predicate.test(10));    // true

1. Predicate<T> or(Predicate<? super T> other)

Predicate<Integer> predicate = number -> number != 0;
predicate = predicate.or(number -> number != 10);
System.out.println(predicate.test(10));    // true  因为是短路或，第一个判断为 true 就直接返回了

1. Predicate<T> negate()

Predicate<Integer> predicate = number -> number != 0;
predicate = predicate.negate();
System.out.println(predicate.test(10));    // false

1. Predicate<T> isEqual(Object targetRef)

System.out.println(Predicate.isEqual("test").test("test"));    // true

1. Predicate<T> not(Predicate<? super T> target)

// 定义一个谓词：判断数字是否大于5
Predicate<Integer> isGreaterThanFive = x -> x > 5;

// 使用 not 方法创建一个逻辑非的谓词：判断数字是否不大于5（即小于等于5）
Predicate<Integer> isNotGreaterThanFive = Predicate.not(isGreaterThanFive);

---

4.3. BiPredicate<T,U>

方法：

接口方法	方法描述
boolean test(T t, U u)	根据给定的两个输入参数进行判断
BiPredicate<T,U> and(BiPredicate<? super T,? super U> other)	返回一个组合判断，将 other 以短路与的方式加入到函数的判断中
BiPredicate<T,U> or(BiPredicate<? super T,? super U> other)	返回一个组合判断，将 other 以短路或的方式加入到函数的判断中
BiPredicate<T,U> negate()	将函数的判断取反

方法示例：

1. test(T t, U u)

BiPredicate<Integer, Integer> biPredicate = (a, b) -> !a.equals(b);
System.out.println(biPredicate.test(1, 2)); // true

1. BiPredicate<T,U> and(BiPredicate<? super T,? super U> other)

BiPredicate<Integer, Integer> biPredicate = (a, b) -> !a.equals(b);
biPredicate = biPredicate.and((a, b) -> a.equals(b));
System.out.println(biPredicate.test(1, 2)); // false

1. BiPredicate<T,U> or(BiPredicate<? super T,? super U> other)

BiPredicate<Integer, Integer> biPredicate = (a, b) -> !a.equals(b);
biPredicate = biPredicate.or((a, b) -> a == b);
System.out.println(biPredicate.test(1, 1)); // true

1. BiPredicate<T,U> negate()

BiPredicate<Integer, Integer> biPredicate = (a, b) -> !a.equals(b);
biPredicate = biPredicate.negate();
System.out.println(biPredicate.test(1, 2)); // false

---

5. Supplier 供应商接口

5.1. 分类

序号	接口	描述
1	Supplier<T>	不提供输入参数，但是返回结果的函数
2	BooleanSupplier	不提供输入参数，但是返回 boolean 结果的函数
3	DoubleSupplier	不提供输入参数，但是返回 double 结果的函数
4	IntSupplier	不提供输入参数，但是返回 int 结果的函数
5	LongSupplier	不提供输入参数，但是返回 long 结果的函数

---

5.2. Supplier<T>

源码：

@FunctionalInterface
public interface Supplier<T> {

    /**
     * 获取一个结果
     *
     * @return 结果
     */
    T get();
}

方法：

接口方法	方法描述
T get()	获取结果值

方法示例：

1. T get()

Supplier<String> supplier = () -> "Hello Jack!";
System.out.println(supplier.get()); // Hello Jack!

---

5.3. BooleanSupplier

源码：

@FunctionalInterface
public interface BooleanSupplier {

    /**
     * 获取函数的执行结果
     *
     * @return 结果
     */
    boolean getAsBoolean();
}

方法：

接口方法	方法描述
boolean getAsBoolean()	获取函数的执行结果

方法示例：

1. boolean getAsBoolean()

BooleanSupplier booleanSupplier = () -> true;
System.out.println(booleanSupplier.getAsBoolean()); // true

---

5.4. DoubleSupplier

源码：

@FunctionalInterface
public interface DoubleSupplier {

    /**
     * 获取函数的执行结果
     *
     * @return 结果
     */
    double getAsDouble();
}

方法：

接口方法	方法描述
double getAsDouble()	获取函数的执行结果

方法示例：

DoubleSupplier doubleSupplier = () -> 2.7;
System.out.println(doubleSupplier.getAsDouble()); // 2.7