欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

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

程序员文章站 2022-06-13 13:51:20
...

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

程序演示:
常用的函数式接口——Predicate接口
默认方法: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);
    }
}

程序演示:
常用的函数式接口——Predicate接口
默认方法: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);
    }
}

常用的函数式接口——Predicate接口
默认方法: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);
    }
}

程序演示:
常用的函数式接口——Predicate接口
练习:集合信息筛选

练习:集合信息筛选
数组当中有多条“姓名+性别”的信息如下,
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);
        }
    }
}

程序演示:
常用的函数式接口——Predicate接口