Java 8 辣么大（lambda）表达式不慌之-----（二）Predicate

Java 8 辣么大（lambda）表达式不慌之—–（二）Predicate

在动用辣么在表达式的时候经常会用到这个函数Predicate<T>，他的定义是：Represents a predicate (boolean-valued function) of one argument.。意思就是他接收一个参数，返回一个boolean类型的结果。举个栗子：

Predicate<String> pre = (x)->{
    return x.equals("hello word!");
};
boolean test = pre.test("hello world!"); // test = false

下面看看Predicate<T>下的一些方法：

第一个就是上面栗子中的test()方法

方法很简单，就是用给定的参数去执行方法，得到返回值。

第二个default Predicate<T> and(Predicate<? super T> other)方法

看实现就知道是将2个函数执行结果取&&，看栗子：

Predicate<Integer> preInt = (x)->{
    return x>0;
};  
Predicate<Number> preNum = (x)->{
    return x.equals(10);
};
preNum.and(preInt).test(10); //编译报错
boolean test = preInt.and(preNum).test(10); //true

首先明确一下，Integer类继承了Number类，再看and方法的参数是Predicate<? super T> other 说明参数中的泛型?一定要是T的超类，在这里就是作为参数的preNum 定义的函数类型一定要是preInt定义的函数类型的超类。所以下面的2种调用方式，第一种编译不通过，第二种正确。
有and，就一定有or，下面是or方法

第三个default Predicate<T> or(Predicate<? super T> other)

不解释，看实现：将2个函数执行结果取||操作。

Predicate<Integer> preInt = (x)->{
    return x>0;
};  
Predicate<Number> preNum = (x)->{
    return x.equals(10);
};
boolean test = preInt.or(preNum).test(5); //true

跟上面的一样，注意参数中的函数的所定义的类型。
有与、有或后面必定有非

第四个default Predicate<T> negate()

看方法名或者实现就知道了，是对原来的方法取非操作，小栗子举一个：

Predicate<Integer> preInt = (x)->{
    return x>0;
};
boolean test = preInt.negate().test(5); // false

---

跟Function一样，Predicate也有传2个参数的BiPredicate接口

接口中的方法与Predicate差不多，不细说了，直接举例子：

BiPredicate<Integer,Integer> biprePlus = (x,y)->{
    return x+y>10;
};
BiPredicate<Integer,Integer> bipreMutip = (x,y)->{
    return x*y>10;
};
boolean t1 = biprePlus.test(3, 5); // false
boolean t2 = biprePlus.and(bipreMutip).test(3, 5); // false
boolean t3 = biprePlus.or(bipreMutip).test(3, 5); // true
boolean t4 = biprePlus.negate().test(3, 5); // true