java8 - 内置函数式接口（Predicate）

在java.util.function中，有内置了一些函数式接口，包括Predicate、Consumer、Function、Supplier等，咱们先看看Predicate。

Predicate

表示一个涉及类型T的布尔表达式时，就可使用Predicate接口。

获取长度为1的字符串

public class PredicateDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "3", "11", "22", "33");
        Predicate<String> predicate = (String str) -> str.length() == 1;
        Predicate<String> orPredicate = (String str) -> "11".equals(str);
        Predicate<String> andPredicate = (String str) -> "1".equals(str);
        filter(list, predicate);
        negateFilter(list, predicate);
        orFilter(list, predicate, orPredicate);
        andFilter(list, predicate, andPredicate);
        equalFilter(list);
        andOrFilter(list, predicate, andPredicate, orPredicate);
        orAndFilter(list, predicate, andPredicate, orPredicate);
    }

    public static <T> void filter(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T t : list) {
            if (predicate.test(t)) {
                result.add(t);
            }
        }
        System.out.println(result);
    }
}

运行结果以下：

咱们传入的T是String类型，返回的是boolean值。

复合

Predicate接口还包括了negate、and和or这三个方法，咱们能够重用已有的Predicate来建立更复杂的Predicate。

negate

获取长度不为1的字符串

咱们在上面的filter方法改造一下

public static <T> void negateFilter(List<T> list, Predicate<T> predicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.negate().test(t)) {
            result.add(t);
        }
    }
    System.out.println(result);
}

运行结果以下：

从negate的源码，能够看到在test方法前加了！，因此打印出[11, 22, 33]

default Predicate<T> negate() {
    return (t) -> !test(t);
}

or

获取长度为1的字符串或者字符串为11

咱们写一个orFilter，orPredicate中，是11字符串也返回true

public static <T> void orFilter(List<T> list, Predicate<T> predicate, Predicate<T> orPredicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.or(orPredicate).test(t)) {
            result.add(t);
        }
    }
    System.out.println(result);
}

运行结果以下：

or的源码：

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

这边加了||，因此不止1, 2, 3返回true，11也返回true。

and

获取长度为1的字符串且字符串为1

andFilter方法中，andPredicate为字符串为1的返回true

public static <T> void andFilter(List<T> list, Predicate<T> predicate, Predicate<T> andPredicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.and(andPredicate).test(t)) {
            result.add(t);
        }
    }
    System.out.println(result);
}

运行结果以下：

and的源码：

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

这边加了&&，因此只返回了1。
若是只是equals，也能够用下面的方法来，用的Predicate.isEqual静态方法。

public static <T> void equalFilter(List<T> list) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (Predicate.isEqual("1").test(t)) {
            result.add(t);
        }
    }
    System.out.println(result);
}

and和or

咱们看看andOrFilter和orAndFilter方法

public static <T> void andOrFilter(List<T> list, Predicate<T> predicate, Predicate<T> andPredicate, Predicate<T> orPredicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.and(andPredicate).or(orPredicate).test(t)) {
            result.add(t);
        }
    }
    System.out.println(result);
}

public static <T> void orAndFilter(List<T> list, Predicate<T> predicate, Predicate<T> andPredicate, Predicate<T> orPredicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.or(orPredicate).and(andPredicate).test(t)) {
            result.add(t);
        }
    }
    System.out.println(result);
}

运行结果以下：
第一个先and，再or。and后，符号条件的只有1，or里面再把11并进来，因此就是1，11。相对于 (A && B) || C。第二个先or，再and。or后，符号条件的是1，2，3，11，and后，只剩下1.相对于 (A or B) && C。