431常用的函数式接口-Predicate接口-默认方法and和432常用的函数式接口-Predicate接口-默认方法or&negate

常用的函数式接口-Predicate接口-默认方法and

/*
        逻辑表达式：可以连接多个判断条件
        &&：与运算符，有false则false
        ||:或运算符，有true则true
        ！：非（取反）运算符：非真则假，非假则真
 */
public class Predicate_and {
    /*
      定义一个方法，方法的参数，传递一个字符串
      传递两个Predicate接口
          一个用于判断字符串的长度是否大于5
          一个用于判断字符串中是否包含a
          两个条件必须同时满足
  */
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
        // pre1.test(s) && pre2.test(s);
        return pre1.and(pre2).test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "qwefxza";
        //调用checkString方法，对字符串进行校验，参数传递字符串和两个Lambda表达式
        boolean b = checkString(s, (String str) -> {
                    //判断字符串的长度是否大于5
                    return str.length() > 5;
                },
                (String str) -> {
                    //判断字符串中是否包含a
                    return str.contains("a");
                }
        );
        System.out.println(b);
    }
}

常用的函数式接口-Predicate接口-默认方法or&negate

or

/*
       default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) ‐> test(t) || other.test(t);
        }
方法内部的两个判断条件，也是使用||运算符连接起来的

 */
public class Predicate_or {
    /*
        定义一个方法，方法的参数，传递一个字符串
        传递两个Predicate接口
            一个用于判断字符串的长度是否大于5
            一个用于判断字符串中是否包含a
            两个条件满足一个即可
    */
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
        // pre1.test(s) || pre2.test(s);
        return pre1.or(pre2).test(s);//等价于pre1.test(s) && pre2.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "qwea";
        //调用checkString方法，对字符串进行校验，参数传递字符串和两个Lambda表达式
        boolean b = checkString(s, (String str) -> {
                    //判断字符串的长度是否大于5
                    return str.length() > 5;
                },
                (String str) -> {
                    //判断字符串中是否包含a
                    return str.contains("a");
                }
        );
        System.out.println(b);
    }
}

negate

/*
    需求：判断一个字符串长度是否大于5
        如果字符串长度大于5，返回false
        如果字符串长度不大于5，返回true
     所以我们可以使用取反符号！对判断结果进行取反

     Predicate接口中有一个方法negate,也表示取反的意思
     default Predicate<T> negate() {
        return (t) ‐> !test(t);
        }

 */
public class Predicate_negate {
    /*
        定义一个方法，方法的参数，传递一个字符串
        使用Predicate接口判断字符串的长度是否大于5
       */
    public static boolean checkString(String s, Predicate<String> pre) {
        //return !pre.test(s);
        return pre.negate().test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "qwef";
        //调用checkString方法，对字符串进行校验，参数传递字符串和Lambda表达式
        /*boolean b = checkString(s, (String str) -> {
                    //判断字符串的长度是否大于5
                    return str.length() > 5;
                }
        );*/

        //优化Lambda
        boolean b =checkString(s,(str)-> str.length() > 5);
        System.out.println(b);
    }
}

标签：Predicate,return,String,默认,test,接口,str,字符串
来源： https://www.cnblogs.com/agzq/p/16496764.html