java中lambada表达式中的Predicate

Predicate 翻译成中文是谓语的意思，那么谓语是对主语动作或状态的陈述或说明，指出“做什么”do what,“是什么”what is this或是“怎么样”how ‘’

它代表只有一个变量的函数，返回 boolean 类型。​

有时候我们需要进行各种判断，从而得到一个 boolean 值的结果。

首先我们来看一下Predicate中的方法：

我们首先来看一下test方法：

/**
     * 根据给定的参数计算此谓语
     *
     * @param t 输入参数
     * @return {@code true} 如果输入参数与谓语匹配则返回true
     * otherwise {@code false} 否则返回false
     */
    boolean test(T t);
           

简单的说明一下使用：

Predicate<String> zfc=t->t.equals("你好");
		boolean test = zfc.test("你好");
		System.out.println(test);  //返回结果true
           

我们再来看一下and方法：

/**
     * 返回表示此谓词和另一个谓词的短路逻辑与的复合谓词。
     * 在判断组合谓词时，如果此谓词为{@code false}, 
     * 则不判断{@code other}其他谓词
     *
     * <p>在评估任一谓词期间抛出的任何异常都会转发给调用者; 
     *  如果对此谓词的判断引发异常，则不会计算{@code other}其他谓词。
     *
     * @param 其他谓词将与此谓词进行逻辑AND运算
     * 
     * @return 一个组合谓词，表示该谓词和{@code other}谓词的短路逻辑和
     * @throws 如果其他谓词为空，则抛出空指针异常
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
           

简单使用范例：

String a1=“hello”;

Predicate<String> containsh=t->t.contains("h");
	Predicate<String> containse=t->t.contains("e");
	
	System.out.println("a1中是否包含："+containsh.and(containse).test(a1));  //返回true 逻辑与的关系 h和e都包含
           

看完逻辑与之后我们来看 或的方法：

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

简单使用范例：

其实跟and差不多，只不过条件不一样

String a1="hello";
	
	Predicate<String> containsh=t->t.contains("h");
	Predicate<String> containse=t->t.contains("s");
	
	System.out.println("a1中是否包含："+containsh.and(containse).test(a1));  //返回true 逻辑或的关系 只包含其中一个就返回true
           

我们看完逻辑或，再来看非的源码：

/**
     * 返回表示此谓词的逻辑否定的谓词。
     * @return 表示此谓词的逻辑否定的谓词
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
           

简单使用范例：

String a1="hello";
Predicate<String> containsh=t->t.contains("h");
Predicate<String> containse=t->t.contains("e");
System.out.println("a1中是否包含："+containsh.negate().test(a1)); //返回false hello中包含h，取反返回false。
           

看完与、或、非我们来看改函数接口最后一个方法isEqual，用于比较相等的对象引用

/**
     * 返回一个谓词，根据{@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);
    }
           

简单使用范例：

String a1="String";
	
		Predicate<String> object=Predicate.isEqual("String");
		
		System.out.println(object.test(a1));
           

Predicate在条件判断结合lambada表达式非常简洁迅速，语义清晰明了，可读性强。