判断是否节假日 接口_Java基础学习之函数式编程Predicate接口（JDK8）

前言

今天继续来学习函数式编程接口之Predicate接口。

---

1. 上源码！

package javax.persistence.criteria;

import java.util.List;

public interface Predicate extends Expression<Boolean> {
    Predicate.BooleanOperator getOperator();

    boolean isNegated();

    List<Expression<Boolean>> getExpressions();

    Predicate not();

    public static enum BooleanOperator {
        AND,
        OR;

        private BooleanOperator() {
        }
    }
}

哎？不对不对，不是这个

应该是这个

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T var1);

    default Predicate<T> and(Predicate<? super T> var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            return this.test(var2) && var1.test(var2);
        };
    }

    default Predicate<T> negate() {
        return (var1) -> {
            return !this.test(var1);
        };
    }

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

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

咳咳，第一段代码希望不要给大家带来困扰，第一段代码其实就是JPA在拼装sql语句时候用的表达式组装类。既然他们的名字一样，那其实他们代表的大致作用也是差不多的，接下来我们依据源代码来剖析一下这个接口。

2. 源码解读

首先是肯定是经典的一个接口只有一个抽象方法，然后接口上面加上

@FunctionalInterface

来做函数式接口的校验。

2.1 and

default Predicate<T> and(Predicate<? super T> var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            return this.test(var2) && var1.test(var2);
        };
    }

该方法返回的是一个Predicate用lambda表达式实例化的一个匿名内部类，我们重点关注一下这个匿名内部类中的返回

return this.test(var2) && var1.test(var2);

返回的是一个boolean值，这点很重要，predicate返回的就是一个boolean值，后面的所有的方法均是如此。

逻辑上是“&&”且的关系，两个条件同时满足返回true，否则返回false。

举个例子：

1. 判断该参数是否为偶数

2. 判断改参数是否大于10

import java.util.function.Predicate;

public class StringBuilderTest {
    public static void main(String[] args) {
        //判断是否为偶数
        Predicate<Integer> predicate1 = integer -> (integer & 1) == 0;
        //判断是否大于10
        Predicate<Integer> predicate2 = integer -> integer > 10;

        System.out.println(predicate1.and(predicate2).test(12));
        System.out.println(predicate1.and(predicate2).test(11));
        System.out.println(predicate1.and(predicate2).test(10));
    }
}

true false false

这样既不用使用很多的ifelse来做判断，而且这些判断条件可以复用，在逻辑上会更加顺畅。

2.2 negate

default Predicate<T> negate() {
        return (var1) -> {
            return !this.test(var1);
        };
    }

我们还是直接看返回，返回的是该判断条件的逻辑取反。

2.3 or

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

返回的是两个判断条件的逻辑取或，只要两个条件有一个为true，即为true，否则为false

2.4 isEqual

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

注意一下，这个方法跟前面的三个是不一样的，这是一个静态方法

（1）这个方法的入参是object 而不是Predicate

（2）这个方法返回的是Predicate，所以他存在的意义其实是在Predicate链式编程的时候传入一个判断条件

（3）注意这个返回的空判断方法和这个三目运算的逻辑

所以在需要做很多判断的时候可以用Predicate接口来执行判断，可以用“且或非”三种逻辑进行灵活组合。

作为函数式编程的第二个接口，特点就是“有入参，返回boolean”。

下一章我们继续学习Function接口