Java8之Predicate函数
这次我们来分享Predicate这个函数，还是按照以往的风格我们来进行对比的操作,话不多说,我们来切入正题—> 将predicate里面的函数一一剖析。
test()方法
-
1.我们直接先来看Predicate这个函数的源码解释
解释一下
-
1 . 代表着一个**“断定式子”**
-
2 . 这是一个实用的接口—>其中的实用方法指的是test方法
**PS:下面就是test()方法的代码介绍*
test方法的作用是:
- 1 . 评估参数里面的表达式(说白了就是验证传进来的参数符不符合规则,后面有例子)
- 2 . 它的返回值是一个boolean类型(这点需要注意一下)。
下面我们进行操作
-
import java.util.function.Predicate;
/**
* 我们来验证一下，那说的比较矛盾的地方。
* 1. 评估参数里面的表达式(说白了就是验证传进来的参数符不符合规则,后面有例子)
* 我们来验证一下这句话，并且解释一下。
*/
public class PredicateTestOne {
public static void main(String[] args) {
PredicateTestOne predicateTestOne = new PredicateTestOne();
Predicate<String> predicate = new Predicate<String>() {
@Override
public boolean test(String s) {
return s.equals("zhangsan");
}
};
System.out.println(predicate.test("lisi"));
System.out.println("--- --- --- --- --- ---");
System.out.println(predicate.test("zhangsan"));
}
}
执行结果:
到这里已经不难理解，为什么说：评估参数里面的表达式
- A.**test()**方法接受一个参数
- B.判断这个参数是否符合test()方法体里面的判断
在这个代码里面：我们可以看得出来test()方法体里面判断的是:传进来的参数s是否等于zhangsan,而张三这个对象是由外部调用传进来的。
但是这个样子违反了1.8的新特性—>函数式编程即:我们需要做到的是将函数作为参数,“说白了就是写更少的代码做更多的事”。,我们这个貌似做不到，如果我们要判断,传入的参数长度是否大于5或者说判断传入的参数是否为奇数或者偶数呢？难道我们还要像以前一样写出多个参数么？当然，不是如果继续那样做,Java8的出现将毫无意义！
下面我们来将上面的问题处理一下:(采用传统的方式和新的方式)
- 1.判断传入的字符串的长度是否大于5
- 2.判断传入的参数是否是偶数
- 3.判断数字是否大于10
传统的方法
import java.util.List;
import java.util.function.Predicate;
/**
* - 1.判断传入的字符串的长度是否大于5
* - 2.判断传入的参数是否是奇数
* - 3.判断数字是否大于10
*/
public class PredicateTestOne {
public static void main(String[] args) {
/** 我们先采用传统的方式 */
/** - 1.判断传入的字符串的长度是否大于5 */
PredicateTestOne predicateTestOne = new PredicateTestOne();
System.out.println(predicateTestOne.judgeStringLength("hello"));
System.out.println(predicateTestOne.judgenumbersOdds(4));
System.out.println(predicateTestOne.judgeSpecialNumbers(-1));
}
/**
*
* - 1.判断传入的字符串的长度是否大于5
*
* @param judgeString 待判断字符串
* @return
*/
public boolean judgeStringLength(String judgeString) {
return judgeString.length() > 5 ? true:false;
}
/**
* - 2.判断传入的参数是否是奇数
*
* @param number 待判断的数字
* @return 1 代表偶数， 0代表奇数
*/
public int judgenumbersOdds(int number) {
return number % 2 == 0 ? 1 : 0;
}
/**
* - 3.判断数字是否大于10
*
* @param number 待判断的数字
* @return 1. 代表大于10 ， 0 代表小于10
*/
public int judgeSpecialNumbers(int number) {
return number > 10 ? 1 : 0;
}
}
Java8中的方法
import java.util.function.Predicate;
/**
* - 1.判断传入的字符串的长度是否大于5
* - 2.判断传入的参数是否是偶数
* - 3.判断数字是否大于10
*/
public class PredicateTestThree {
public static void main(String[] args) {
PredicateTestThree predicate = new PredicateTestThree();
/** - 1.判断传入的字符串的长度是否大于5 */
System.out.println(predicate.judgeConditionByFunction(12345,value -> String.valueOf(value).length() > 5));
/** - 2.判断传入的参数是否是奇数 */
System.out.println(predicate.judgeConditionByFunction(4,value -> value % 2 == 0));
/** - 3.判断数字是否大于10 */
System.out.println(predicate.judgeConditionByFunction(-1, value-> value > 10));
}
public boolean judgeConditionByFunction(int value,Predicate<Integer> predicate) {
return predicate.test(value);
}
}
总结一下吧,上面的代码主要说了两件事
-
- 用更少的代码干更多的事
-
- 解释了test()方法的作用 —> 评估参数里面的表达式
###Predicate中的其他的方法
- 1.and()方法,我们先来看下源代码里面的解释
通俗一点解释: 等同于我们的逻辑与&&,存在短路特性
看下他的代码:return:(t) -> test(t) && other.test(t) ,我们的test()方法是返回boolean的，这个是返回一个Predicate,所以我们可以做一个大胆的推断,and方法是不是要和test()方法去混合使用?下面我们去验证这个猜测以及去演练这个方法
package com.xsh.java8;
import java.util.function.Predicate;
/**
* 我们就来看看返回的是什么
*/
public class PredicateAND {
public static void main(String[] args) {
PredicateAND predicateAND = new PredicateAND();
System.out.println(predicateAND.testAndMethod("zhangsan",
stringOne -> stringOne.equals("zhangsan"),stringTwo -> stringTwo.length() > 5));
}
/**
*
* @param stringOne 待判断的字符串
* @param predicateOne 断定表达式1
* @param predicateTwo 断定表达式2
* @return 是否满足两个条件
*/
public boolean testAndMethod(String stringOne, Predicate<String> predicateOne,Predicate<String> predicateTwo) {
return predicateOne.and(predicateTwo).test(stringOne);
}
}
上面我们可以知道and方法返回的是Predicate,那么我们是不是可以无限嵌套下去呢？下面我们来试试
import java.util.function.Predicate;
/**
* 我们就来看看返回的是什么
*/
public class PredicateAND {
public static void main(String[] args) {
PredicateAND predicateAND = new PredicateAND();
// System.out.println(predicateAND.testAndMethod("zhangsan",stringOne -> stringOne.equals("zhangsan"),stringTwo -> stringTwo.length() > 5));
System.out.println(predicateAND.testAndMethod("zhangsan"
, stringOne -> stringOne.equals("zhangsan")
,stringTwo -> stringTwo.length() >5
,stringThree -> stringThree.length() % 2 == 0));
}
/**
*
* @param stringOne 待判断的字符串
* @param predicateOne 断定表达式1
* @param predicateTwo 断定表达式2
* @return 是否满足两个条件
*/
public boolean testAndMethod(String stringOne, Predicate<String> predicateOne,
Predicate<String> predicateTwo, Predicate<String> predicateThree) {
return predicateOne.and(predicateTwo).and(predicateThree).test(stringOne);
}
}
结论:可行
-
2 .negate()方法,我们先来看下源代码里面的解释
通俗一点解释: 等同于我们的逻辑非
ps:返回值一样需要注意，是Predicate,上面已经验证过了,可以进行嵌套。
看下他的代码:(t) -> !test(t),不用想的太复杂,就是咱们的逻辑非,下面我们去演练这个方法
import java.util.function.Predicate;
public class PredicateNegate {
public static void main(String[] args) {
PredicateNegate predicateNegate = new PredicateNegate();
System.out.println(predicateNegate.testNageteMethod("zhangsan",stringOne -> stringOne.equals("zhangsan")));
}
public boolean testNageteMethod(String stringValue, Predicate<String> predicate) {
return predicate.negate().test(stringValue);
}
}
- 3.or()方法,我们先来看下源代码里面的解释
通俗一点解释: 等同于我们的逻辑或
ps:返回值一样需要注意，是Predicate,上面已经验证过了,可以进行嵌套。
看下他的代码:(t) -> test(t) || other.test(t) ,不用想的太复杂,就是咱们的逻辑或,就是两个或多个条件满足一个就好了,下面我们去演练这个方法
import java.util.HashMap;
import java.util.Map;
import java.util.function.Predicate;
public class PredicateOr {
public static void main(String[] args) {
PredicateOr predicateOr = new PredicateOr();
// System.out.println(predicateAND.testAndMethod("zhangsan",stringOne -> stringOne.equals("zhangsan"),stringTwo -> stringTwo.length() > 5));
System.out.println(predicateOr.testOrMethod("zhangsan"
, stringOne -> stringOne.equals("zhangsan111")
,stringTwo -> stringTwo.length() > 50
,stringThree -> stringThree.length() % 2 == 0));
}
/**
*
* @param stringOne 待判断的字符串
* @param predicateOne 断定表达式1
* @param predicateTwo 断定表达式2
* @return 是否满足两个条件
*/
public boolean testOrMethod(String stringOne, Predicate<String> predicateOne, Predicate<String> predicateTwo, Predicate<String> predicateThree) {
// return predicateOne.and(predicateTwo).test(stringOne);
return predicateOne.or(predicateTwo).or(predicateThree).test(stringOne);
}
}
- 4.isEqual()方法,我们先来看下源代码里面的解释
根据注释的解释就是:判断两个对象是否相等—> 使用的是Objects里面的equals()方法进行比较
*Objects解释如下:
解释如下: 本类由一些操作对象的静态工具方法构成，这些工具方法包括了非空检查、方法的非空参数检查、
比较对象的hashCode、为对象返回一个字符串表示、比较两个对象,说的很明显了，比较的两个对象的HashCode值
通俗一点解释: 先判断对象是否为NULL—> 这个由Objects里面的isNull进行判断,如果，不为Null的话,那么接下来用java.lang.object里面的equals()方法进行比较,下面我们去演练这个方法
import java.util.function.Predicate;
public class PredicateIsEquals {
public static void main(String[] args) {
PredicateIsEquals predicate = new PredicateIsEquals();
String strNull = null;
System.out.println(predicate.testMethodIsEquals("zhangsan","zhangsan"));
System.out.println("~~~ ~~~ ~~~ ~~~");
System.out.println(predicate.testMethodIsEquals("zhangsan","lisi"));
System.out.println("~~~ ~~~ ~~~ ~~~");
System.out.println(predicate.testMethodIsEquals(strNull,"zhangsan")); /* 我们来Debug一下这个程序*/
}
public boolean testMethodIsEquals(String strValue, String strValue2) {
return Predicate.isEqual(strValue).test(strValue2);
}
}
Debug为NULL的情况:
- １.第一步
- ２.第二步
- ３.猜测与结果
如果目标参数Null的时候,就需要判断第二个参数是否也为Null,下面我们将第二个参数也换成Null测试一下
import java.util.function.Predicate;
public class PredicateIsEquals {
public static void main(String[] args) {
PredicateIsEquals predicate = new PredicateIsEquals();
String strNull = null;
String strNull2 = null;
System.out.println(predicate.testMethodIsEquals("zhangsan","zhangsan"));
System.out.println("~~~ ~~~ ~~~ ~~~");
System.out.println(predicate.testMethodIsEquals("zhangsan","lisi"));
System.out.println("~~~ ~~~ ~~~ ~~~");
System.out.println(predicate.testMethodIsEquals(strNull,strNull2)); /* 我们来Debug一下这个程序*/
}
public boolean testMethodIsEquals(String strValue, String strValue2) {
return Predicate.isEqual(strValue).test(strValue2);
}
}
如果，有任何问题，请指正，谢谢。