常用的函数式接口——Predicate接口

Predicate接口：
java.util.function.Predicate接口
作用：对某种数据类型的数据进行判断，结果返回一个boolean值

抽象方法：test:
Predicate接口中包含了一个抽象方法：
boolean test(T t):用来对指定数据类型数据进行判断的方法
结果;
符合条件，返回true
不符合条件，返回false
使用案例：

public class Demo01Predicate {
    /*
        定义一个方法
        参数传递一个String类型的字符串
        传递一个Predicate接口，泛型使用String
        使用Predicate中的方法test对字符串进行判断，并把判断的结果返回
    */
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }

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

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

程序演示：

默认方法：and：
逻辑表达式：可以连接多个判断条件
&&：与运算符，有false则false
||:或运算符，有true则true
！：非（取反）运算符：非真则假，非假则真

需求：判断一个字符串，有两个判断的条件
    1.判断字符串的长度是否大于5
    2.判断字符串中是否包含a
两个条件必须同时满足，我们就可以使用&&运算符连接连个条件

Predicate接口中有一个方法and，表示并且关系，也可以用于连接两个判断条件
default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) ‐> this.test(t) && other.test(t);
}
方法内部的两个判断条件，也是使用&&运算符连接起来的

使用案例：

public class Demo02Predicate_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);//等价于pre1.test(s) && 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);
    }
}

程序演示:

默认方法：or:
Predicate接口中有一个方法or，表示并且关系，也可以用于连接两个判断条件

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

使用案例：

public class Demo03Predicate_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 Demo04Predicate_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);
    }
}

程序演示：

练习：集合信息筛选

练习：集合信息筛选
数组当中有多条“姓名+性别”的信息如下，
String[] arry = {"迪丽热巴，女","古力娜扎，女","马尔扎哈，男","赵丽颖，女"};
请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合ArrayList 中，
需要同时满足两个条件：
    1. 必须为女生；
    2. 姓名为4个字。

分析：
    1.有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
    2.必须同时满足两个条件，所以可以使用and方法连接两个判断条件

代码：

public class Demo05Test {
    /*
        定义一个方法
        方法的参数传递一个包含人员信息的数组，
        传递两个Predicate接口，用于对数组中的信息进行过滤
        把满足条件的信息存到ArrayList集合中并返回
    */
    public static ArrayList<String> filter(String[] arr, Predicate<String> pre1, Predicate<String> pre2) {
        //定义一个ArrayList集合，存储过滤之后的信息
        ArrayList<String> list = new ArrayList<>();
        //遍历数组，获取数组中的每一条信息
        for (String message : arr) {
            //使用Predicate接口中的方法test对获取到的字符串进行判断
            boolean b = pre1.and(pre2).test(message);
            //对得到的布尔值进行判断
            if (b) {
                //条件成立，两个条件都满足，把信息存储到ArrayList集合中
                list.add(message);
            }
        }
        //把集合返回
        return list;
    }

    public static void main(String[] args) {
        //定义一个储存字符串的数组
        String[] arry = {"迪丽热巴，女", "古力娜扎，女", "马尔扎哈，男", "赵丽颖，女"};
        //调用filter方法，传递字符串数组和两个Lambda表达式
        ArrayList<String> list = filter(arry, (String s) -> {
            return s.split("，")[1].equals("女");
        }, (String s) -> {
            return s.split("，")[0].length() == 4;
        });
        System.out.println(list);

        //遍历集合
        for (String s : list) {
            System.out.println(s);
        }
    }
}

程序演示：