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);
    }
}

总结一下吧,上面的代码主要说了两件事

1. 用更少的代码干更多的事
1. 解释了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);
    }
}

如果，有任何问题，请指正，谢谢。

今天的文章Java8之Predicate函数[通俗易懂]分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：http://bianchenghao.cn/78057.html

Java8之Predicate函数[通俗易懂]

test()方法

相关推荐

发表回复