Java—Predicate接口 – 奥灵阁技术团队

谓词：用来代替或者展示其客体性质、特征或者客体之间关系的词项。谓词提出问题其答案是true或false，或者换句话说是yes或no。在计算机科学中，谓词是以函数的方式体现的。

下面我们用一些实际的代码示例来说明Java语言中的谓词函数（函数式接口）—— Predicate 的用法：

1、test方法

这是谓词接口的抽象方法，它接受一个泛型类T作为实参，返回一个布尔型的结果【boolean test(T t)】，来判断输入的值是否满足相应的条件。

private void test(){

    //判断输入的数值是否大于20
    Predicate<Integer> predicate = age -> age > 20;

    System.out.println(predicate.test(18));
    System.out.println(predicate.test(21));
}

输出结果：

false
true

2、And方法

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

这个And函数接受一个谓词对象做为参数，并且返回一个复合型的谓词作为返回值，用来连接两个谓词，相当于逻辑运算符中的与（&&）操作。

private void andTest(){
    Predicate<Integer> smallAge = (age) -> age > 15;
    Predicate<Integer> bigAge = (age) -> age < 21;

    System.out.println(smallAge.and(bigAge).test(18));
    System.out.println(smallAge.and(bigAge).test(22));
    System.out.println(smallAge.and(bigAge).test(13));
}

我们定义了两个年龄段，smallAge为大于15岁，而bigAge为小于21岁，如果使用And将两个谓词进行连接，那么就限定年龄为要么大于15岁，要么小于21岁才能满足要求，因此只有18返回true，输出结果如下：

true
false
false

3、Or方法

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

这个Or函数接受一个谓词对象做为参数，并且返回一个复合型的谓词作为返回值，用来连接两个谓词，相当于逻辑运算符中的或（||）操作。

private void andTest(){
    Predicate<Integer> smallAge = (age) -> age > 21;
    Predicate<Integer> bigAge = (age) -> age < 15;

    System.out.println(smallAge.or(bigAge).test(18));
    System.out.println(smallAge.or(bigAge).test(22));
    System.out.println(smallAge.or(bigAge).test(13));
}

我们把And函数示例中的值调换一下位置。定义两个年龄段，smallAge为大于21岁，而bigAge为小于15岁，如果使用Or将两个谓词进行连接，那么就限定年龄为要么大于21岁，要么小于15岁才能满足要求，因此只有18返回false，输出结果如下：

false
true
true

4、Equal方法

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

它是一个静态方法，不需要实例化可以直接调用，其参数可以是任何对象。调用它会返回一个新的谓词，这个谓词内部的处理逻辑是能过调用Object的equal来判断对象是否相等，如：

private void equalTest(){
    Predicate<String> currentAge = Predicate.isEqual("tdjgamtam");

    System.out.println(currentAge.test("wfwfwf"));
    System.out.println(currentAge.test("tdjgamtam"));
}

上面输出的结果为：

false
true

5、Not方法

    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }

它也是一个静态方法，不需要实例化可以直接调用。它的参数是一个谓词，调用它会返回一个新的谓词，这个新谓词是原有谓词逻辑的取反。如：

private void notTest(){
    Predicate<Integer> currentAge = age -> age == 20;
    Predicate<Integer> noCurrentAge = Predicate.not(currentAge);

    System.out.println(noCurrentAge.test(20));
    System.out.println(noCurrentAge.test(21));
}

原有的谓词currentAge的判断条件是年龄等于20，新谓词noCurrentAge将原有谓词的逻辑取反。因此上面输出的结果为：

false
true

留下评论取消回复