Java 8之Predicate接口方法应用

一、简介

    java.util.function.Predicate接口，作用：对某种数据类型的数据进行判断，结果返回一个boolean值。

二、源码

@FunctionalInterface
public interface Predicate<T> {

	//传入参数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);
    }
}

• 抽象方法test()：用来对指定数据类型数据进行判断的方法结果，符合条件，返回true；不符合条件，返回false。
• 默认方法and()：逻辑表达式：可以连接多个判断条件，&&：与运算符，有false则false，||:或运算符，有true则true，!：非（取反）运算符：非真则假，非假则真。
• 默认方法or()：Predicate接口中有一个方法or，表示并且关系，也可以用于连接两个判断条件。
• 默认方法negate()：取反操作。

三、使用示例

• test()方法使用。

public class PredicateTest {

    public static void main(String[] args) {
        predicateTest();
    }

    public static void predicateTest() {
        boolean flag = predicateTrueOrFalse("张三", "张三"::equals);
        //输出：predicateTest-->true
        System.out.printf("predicateTest--> {%s}%n", flag);
    }

    /**
     * Predicate接口：
     * java.util.function.Predicate接口
     * 作用：对某种数据类型的数据进行判断，结果返回一个boolean值
     *
     * 抽象方法：test:
     * Predicate接口中包含了一个抽象方法：
     * boolean test(T t):用来对指定数据类型数据进行判断的方法
     * 结果;
     * 符合条件，返回true
     * 不符合条件，返回false
     */
    public static <T> boolean predicateTrueOrFalse(T t, Predicate<T> predicate) {
        return predicate.test(t);
    }
   
}

• test()方法使用，先执行predicate，再执行predicate2 and连接 两者必须都是true 结果才是true。

public class PredicateAnd {

    public static void main(String[] args) {
        predicateAndTest();
    }

    public static void predicateAndTest() {
        boolean flag = predicateAnd("张三", "张三"::equals, s -> s.length() == 12);
        //输出：predicateAndTest-->true
        System.out.printf("predicateAndTest-->{} {%s}%n", flag);

        flag = predicateAnd("张三", "张三"::equals, s -> s.length() == 2);
        //输出：predicateAndTest-->false
        System.out.printf("predicateAndTest-->{} {%s}%n", flag);
    }

    /**
     * 先执行predicate，再执行predicate2 and连接 两者必须都是true 结果才是true
     */
    public static <T> boolean predicateAnd(T t, Predicate<T> predicate, Predicate<T> predicate2) {
        return predicate.and(predicate2).test(t);
    }

}

• or()方法使用，先执行predicate，再执行predicate2 or 连接其中有一个是true，结果就是true。

public class PredicateOr {

    public static void main(String[] args) {
        predicateOrTest();
    }

    public static void predicateOrTest() {
        boolean flag = predicateOr("张三", "张三"::equals, s -> s.length() == 12);
        //输出：predicateOrTest-->true
        System.out.printf("predicateAndTest-->{} {%s}%n", flag);

        flag = predicateOr("张三", "张三"::equals, s -> s.length() == 2);
        //输出：predicateOrTest-->true
        System.out.printf("predicateAndTest-->{} {%s}%n", flag);
    }

    /**
     * 先执行predicate，再执行predicate2 or连接 其中有一个是true 结果就是true
     */
    public static <T> boolean predicateOr(T t, Predicate<T> predicate, Predicate<T> predicate2) {
        return predicate.or(predicate2).test(t);
    }

}

•  negate()方法使用，取反操作。

public class PredicateNegate {

    public static void main(String[] args) {
        predicateNegateTest();
    }

    public static void predicateNegateTest() {
        boolean flag = predicateNegate("张三", "张三"::equals);
        //输出：predicateNegateTest-->false
        System.out.printf("predicateNegateTest-->{} {%s}%n", flag);
    }

    /**
     * 执行predicate 取反操作
     */
    public static <T> boolean predicateNegate(T t, Predicate<T> predicate) {
        return predicate.negate().test(t);
    }

}