Java Predicate接口源码使用示例

@FunctionalInterface
public interface Predicate<T> {
    /**
     * 具体过滤操作 需要被子类实现.
     * 用来处理参数T是否满足要求,可以理解为 条件A
     */
    boolean test(T t);
    /**
     * 调用当前Predicate的test方法之后再去调用other的test方法,相当于进行两次判断
     * 可理解为 条件A && 条件B
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    /**
     * 对当前判断进行"!"操作,即取非操作，可理解为 ! 条件A
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    /**
     * 对当前判断进行"||"操作,即取或操作,可以理解为 条件A ||条件B
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    /**
     * 对当前操作进行"="操作,即取等操作,可以理解为 A == B
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

// 将实现用户名校验规则的lambda函数赋给Predicate实例
Predicate<String> isUserNameValid = u -> u != null && u.length() > 5 && u.length() < 10;
// 调用test方法，test方法的参数就是待检测的字符串（也就是喂给Predicate实例的数据），将会输出true
System.out.println(isUserNameValid.test("Howard"));
// 同样的道理
Predicate<String> isPasswordValid = p -> p != null && p.length() > 8 && p.length() < 15;
System.out.println(isPasswordValid.test("123456789"));

Arrays.asList("A1234567890", "Howard", "Tommy", "Jone").stream()
     .filter(str -> str.length() > 5)
     .filter(str -> str.length() < 10)
     .collect(Collectors.toList());

java.util.stream.Stream<T>
public abstract Stream<T> filter(java.util.function.Predicate<? super T> predicate)

Predicate<String> predicate1 = str -> str.startsWith("A");
Predicate<String> predicate2 = str -> str.length() > 5;
Predicate<String> predicate3 = str -> str.length() < 10;
predicate1.and(predicate2).and(predicate3).test("A12347");  // true

public class Validator<T> {
    private Predicate<T> predicate;
    public Validator() {
    	// 将predicate初始化为true
        this.predicate = t -> true;
    }
	// 添加校验策略，由于该函数返回this，因此可以无限使用and串联
    public Validator<T> with(Predicate<T> predicate) {
        this.predicate = this.predicate.and(predicate);
        return this;
    }
	// 执行校验，并返回校验结果
    public boolean validate(T t) {
        return this.predicate.test(t);
    }
}
public static void main(String[] args) {
    boolean result = new Validator<String>()
        .with(u -> u != null)
        .with(u -> u.length() > 5)
        .with(u -> u.length() < 10)
        .validate("Howard");
    System.out.println(result); // true
}