常用函数式接口——Predicate

Predicate<T>:常用的四个方法

       1. boolean test(T t):对给定的参数进行判断（判断逻辑由Lambda表达式实现）返回一个布尔值

        2.default Predicate<T>negate():返回一个逻辑的否定，对应的逻辑非

        3.default Predicate<T>and(Predicate other):返回一个组合判断，对应短路与

        4.default Predicate<T> or(Predicate other):返回一个组合判断，对应短路或

        Predicate<T>接口通常用于判断参数是否满足指定的条件

---

方法1和方法2代码展示：

package com.aynu24;

//    1.boolean test(T t):对给定的参数进行判断（判断逻辑由Lambda表达式实现）返回一个布尔值
//
//    2.default Predicate<T>negate():返回一个逻辑的否定，对应的逻辑非

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
//        boolean b1= checkString("hello",(String s)->{
//            return s.length()>8;
//        });

        boolean b1= checkString("hello",s->
             s.length()>8);

        boolean b2= checkString("helloworld",s->
                s.length()>8);

        System.out.println(b1);
        System.out.println(b2);
    }
    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre){
//        return pre.test(s);
//        return !pre.test(s);
        return pre.negate().test(s);
    }
}

true
false

---

方法3和方法4代码演示

package com.aynu24;

//    3.default Predicate<T>and(Predicate other):返回一个组合判断，对应短路与
//
//    4.default Predicate<T> or(Predicate other):返回一个组合判断，对应短路或

import java.util.function.Predicate;

public class PredicateDemo2 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("helloworld", s -> s.length() > 8);
        System.out.println(b2);

        boolean b3 = checkString("hello",s -> s.length()>8,s -> s.length()<15);
        System.out.println(b3);

        boolean b4 = checkString("helloworld",s -> s.length()>8,s -> s.length()<15);
        System.out.println(b4);
    }

    //同一个字符串给出不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
//        boolean b1 = pre1.test(s);
//        boolean b2 = pre2.test(s);
//        boolean b = b1 && b2;
//        return b;

        //    3.default Predicate<T>and(Predicate other):返回一个组合判断，对应短路与
//        return pre1.and(pre2).test(s);

        //    4.default Predicate<T> or(Predicate other):返回一个组合判断，对应短路或
        return pre1.or(pre2).test(s);
    }

    //判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }
}

false
true
true
true 

---

练习：

String[] strArray = {"林青霞，30"，"柳岩，34"，"张曼玉，35"，"貂蝉，31"，"王祖贤，33"}；

字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合

同时满足如下要求：姓名长度大于2；年龄大于33

package com.aynu24;

//练习：
//
//        String[] strArray = {"林青霞，30"，"柳岩，34"，"张曼玉，35"，"貂蝉，31"，"王祖贤，33"}；
//
//        字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
//
//        同时满足如下要求：姓名长度大于2；年龄大于33
//
//分析：
//        有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
//        必须同时满足两个条件，所以可以使用and方法连接两个判断条件

import java.util.ArrayList;
import java.util.function.Predicate;

public class PredicateTest {
    public static void main(String[] args) {

        String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};

        ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);

        for (String str : array) {
            System.out.println(str);
        }
    }

    //请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
    private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
        //定义一个集合
        ArrayList<String> array = new ArrayList<String>();

        //遍历数组
        for (String str : strArray) {
            if (pre1.and(pre2).test(str)) {
                array.add(str);

            }
        }

        return array;

    }
}

张曼玉,35