常用函数式接口_Predicate

1.java.util.function.Predicate接口

1.1 作用：

• 对某种数据类型的数据进行判断，结果返回一个boolean值

1.2 Predicate接口中包含一个抽象方法：

• boolean test(T t)：用来对指定数据类型数据进行判断的方法
  结果：
  符合条件，返回true
  不符合条件，返回false

package com.FunctionalInterface.Predicate;

import java.util.function.Predicate;

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

   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 s = "abcde";

        //调用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);
    }
}

2.逻辑表达式：

可以连接多个判断的条件

• &&：与运算符，有false则false
• ||:或运算符，有true则true
• !:非（取反）运算符，非假则真

2.1 Predicate接口的方法and

2.1.1 需求：判断一个字符串，有两个判断的条件

• 1.判断字符串的长度是否大于5

• 2.判断字符串中是否包含a

• 两个条件必须同时满足，我们就可以使用&&运算符连接两个条件

2.1.2 Predicate接口中有一个方法and,表示并且关系，也可以用于连接两个判断条件

  default Predicate<T> and(Predicate<? super T> other){
  Objects.requireNonNull(other);
  return (t) -> this.test(t) && other.test(t);
  }

方法内部的两个判断条件，也是使用&&运算符连接起来的。

package com.FunctionalInterface.Predicate;

import java.util.function.Predicate;

/*
  逻辑表达式：可以连接多个判断的条件
  &&：与运算符，有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){
//       return pre1.test(s)&&pre2.test(s);
      return pre1.and(pre2).test(s);  //等价于return pre1.test(s)&&pre2.test(s);
    }

    public static void main(String[] args) {
        //调用一个字符串
        String s = "abcdef";

        //调用checkString方法，参数传递字符串和两个Lambda表达式
        boolean b = checkString(s, (String str) -> {
            //判断字符串的长度是否大于5
            return str.length() > 5;
        }, (String str) -> {
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}

2.2 Predicate接口的方法or

2.2.1 需求：判断一个字符串，有两个判断的条件

• 1.判断字符串的长度是否大于5
• 2.判断字符串中是否包含a

满足一个条件即可，我们就可以使用||运算符连接两个条件。

2.2.2 Predicate接口中有一个方法or,表示或者关系，也可以用于连接两个判断条件

  default Predicate<T> and(Predicate<? super T> other){
  Objects.requireNonNull(other);
  return (t) -> this.test(t) || other.test(t);
  }

方法内部的两个判断条件，也是使用||运算符连接起来的。

package com.FunctionalInterface.Predicate;

import java.util.function.Predicate;

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

  Predicate接口中有一个方法or,表示或者关系，也可以用于连接两个判断条件
  default Predicate<T> and(Predicate<? super T> other){
  Objects.requireNonNull(other);
  return (t) -> this.test(t) || other.test(t);
  }
   方法内部的两个判断条件，也是使用||运算符连接起来的
 */
public class Demo03Predicate_or {
    /*
   定义一个方法，方法的参数，传递一个字符串
   传递两个Predicate接口
       一个用于判断字符串长度是否大于5；
       一个用于判断字符串是否包含a
       两个条件满足一个即可
 */
    public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2){
//       return pre1.test(s)||pre2.test(s);
        return pre1.or(pre2).test(s);  //等价于return pre1.test(s)||pre2.test(s);
    }
    public static void main(String[] args) {
        //调用一个字符串
        String s = "abc";

        //调用checkString方法，参数传递字符串和两个Lambda表达式
        boolean b = checkString(s, (String str) -> {
            //判断字符串的长度是否大于5
            return str.length() > 5;
        }, (String str) -> {
            //判断字符串中是否包含a
            return str.contains("a");
        });
        System.out.println(b);
    }
}

2.3 Predicate接口的方法negate

2.3.1 需求：判断一个字符串的长度是否大于5

• 如果字符串的长度大于5，那么返回false

• 如果字符串的长度不大于5，那么返回true

所以我们可以使用取反符号！对判断的结果进行取反

2.3.2 Predicate接口中有一个方法negate,也表示取反的意思

  default Predicate<T> negate(){
     return (t) -> !test(t);
  }

代码如下：

package com.FunctionalInterface.Predicate;
import java.util.function.Predicate;

/*
      需求：判断一个字符串的长度是否大于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);  //等效于return !pre.test(s);
    }

    public static void main(String[] args) {
        //定义一个字符串
        String s = "abc2222";
        //调用checkString方法，参数传递字符串和Lambda表达式
        boolean b = checkString(s, (String str) -> {
            return str.length() > 5;
        });
        System.out.println(b); //false
    }
}

3.练习：集合信息筛选

3.1 数组当中有多条"姓名+性别"的信息如下：

String[] array = {"迪丽热巴,女","古力娜扎,女","马儿扎哈,男","赵丽颖,女"};

请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，
3.2 需要同时满足两个条件：

• 1.必须为女生;

• 2.姓名为4个字。

3.3 分析：

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

package com.FunctionalInterface.Predicate;

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

/*
    练习：集合信息筛选
    数组当中有多条"姓名+性别"的信息如下，
    String[] array = {"迪丽热巴,女","古力娜扎,女","马儿扎哈,男","赵丽颖,女"};
    请通过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 s : arr) {
            //使用Predicate接口中的方法test对获取到的字符串进行判断
            boolean b = pre1.and(pre2).test(s);
            //对得到的布尔值进行判断
            if (b){
                //条件成立，两个条件都满足，把信息存储到ArrayList集合中
                list.add(s);
            }
        }
        //把集合返回
        return list;
    }

    public static void main(String[] args) {
        //定义存储字符串的数组
        String[] array = {"迪丽热巴,女","古力娜扎,女","马儿扎哈,男","赵丽颖,女"};
        //调用filter方法，传递字符串数组和两个Lambda表达式
        ArrayList<String> list = filter(array, (String str) -> {
            //获取字符串中的性别，判断是否为女
            return str.split(",")[1] .equals("女");
        }, (String str) -> {
            //获取字符串中的姓名，判断长度是否为4个字符
            return str.split(",")[0].length() == 4;
        });
        //遍历集合
        for (String s : list) {
            System.out.println(s.toString());
        }
    }
}