Predicate接口的理解与应用

最新推荐文章于 2024-05-05 07:19:27 发布

郭度自信

最新推荐文章于 2024-05-05 07:19:27 发布

阅读量597

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_58202543/article/details/127687623

版权

Predicate接口

一、Predicate接口

百度for谓词 Predicate ：用来代替或者展示其客体性质、特征或者客体之间关系的词项。根据《现代汉语》的定义,汉语的体词包括名词,数词,量词；汉语的谓词可以包括一切的例句。

百度for客体：意思是指存在于主体之外的客观事物。也就是客观的描述，描述他是什么，例如有个数，你描述它是大于五的，其实这个数是不是大于5的还不知道。具体这个主体数是啥还得看你用什么进行填充。

举例：

"猫是动物"一句中的"是"就是一个谓词，而"猫"是客体。 “3 大于 2"中"大于"是一个谓词。
表示某个确定判定的谓词称为谓词常项。如上述两个谓词"是”、“大于”。

1、是什么？

它是一个布尔值的函数接口
Predicate这个单词的英语含义是断言（假设）

boolean值非真既假，可以说是断言，例如 x -> x>4 ,断言当前这个对象要大于4.正如上面的猫是动物，x -> x=动物，x代表各种东西，如果你的x是猪，那猪是动物，就是对的，这个predicate也就是客体，

2、为什么？

Java语言也是一种语言，语言就是用来表达的，你谓词这个也是语言中的一种语法词，用它去表达你用Java语言要表达的意思，例如某个是什么，这个对主体的客观描述就用这个predicate函数接口。

3、怎么样？

在这里插入图片描述

Predicate<String> isUserNameValid = u -> u != null && u.length() > 5 && u.length() < 10;

T是泛型，看你传入什么作为对象去操作，这里是Strng ,也就是操作字符串。断言这字符串怎么样，写相关条件。

这个T，以前听课程入门的时候，有听到老师是把它类比为猪肉，羊肉，牛肉等，这样去举例，也就是去断言，描述这个猪肉，你说这个猪肉是烂的，x -> x = 烂，那它可不一定是烂的，这个predicate就有个判断的行为，test，传进入一个好猪肉，那它就返回了false,表示你的断言错误，还有好几个其他的功能性方法。

所以对于以上java代码的解释就是，将u比喻为一块猪肉，u!=null 可觉得是此猪肉是否是烂的， && 长度是否大于5厘米和长度是否在10厘米之内。

二、功能性方法

1、test(T t)

在这里插入图片描述

test是Predicate的功能方法。它在给定的参数上评估这个谓词。

例1：

PredicateTestDemo001.java

import java.util.function.Predicate;
public class PredicateTestDemo1 {
  public static void main(String[] args) {
 // Is username valid
 Predicate<String> isUserNameValid = u -> u != null && u.length() > 5 && u.length() < 10;
 System.out.println(isUserNameValid.test("guozebiao")); //true
 // Is password valid
 Predicate<String> isPasswordValid = p -> p != null && p.length() > 8 && p.length() < 15;
 System.out.println(isPasswordValid.test("guozebiao123")); //true
 // Word match
 Predicate<String> isWordMatched = s -> s.startsWith("Mr.");
 System.out.println(isWordMatched.test("Mr. guozb")); //true
 //Odd numbers
 Predicate<Integer> isEven = n -> n % 2 == 0;
 for(int i = 0 ; i < 5 ; i++) {
   System.out.println("Is "+ i + " even: " + isEven.test(i));
 }
  }
}

输出结果：

true
true
true
Is 0 even: true
Is 1 even: false
Is 2 even: true
Is 3 even: false
Is 4 even: true

例2：

PredicateTestDemo2.java

import java.util.function.Function;
import java.util.function.Predicate;
public class PredicateTestDemo2 {
  public static void main(String[] args){
    Predicate<Student> maleStudent = s-> s.getAge() >= 20 && "male".equals(s.getGender());
    Predicate<Student> femaleStudent = s-> s.getAge() > 18 && "female".equals(s.getGender());
    // ---
    Function<Student,String> maleStyle = s-> "Hi, You are male and age "+s.getAge();
    Function<Student,String> femaleStyle = s-> "Hi, You are female and age "+ s.getAge();
   // ---
    Student s1 = new Student("Gauri", 20,"female");
    if(maleStudent.test(s1)){
        System.out.println(s1.customShow(maleStyle));
    }else if(femaleStudent.test(s1)){
        System.out.println(s1.customShow(femaleStyle));
    }      
  }

结果： Hi, You are female and age 20

2、and

在这里插入图片描述

2.1 说明

and是Predicate的默认方法，它返回一个组成的谓词，表示这个谓词和其他谓词的短路逻辑AND。在评估组成的谓词时，**如果这个谓词是假的，那么其他谓词将不会被评估。**在错误的情况下，如果此谓词抛出错误，那么其他谓词将不会被评估。

PredicateAndDemo.java

import java.util.function.Predicate;
public class PredicateAndDemo {
  public static void main(String[] args) {
 Predicate<Student> isMaleStudent = s -> s.getAge() >= 20 && "male".equals(s.getGender());
 Predicate<Student> isFemaleStudent = s -> s.getAge() > 18 && "female".equals(s.getGender());
 Predicate<Student> isStudentPassed = s -> s.getMarks() >= 33;
 // Testing if male student passed.
 Student student1 = new Student("Mahesh", 22, "male", 30);
 Boolean result = isMaleStudent.and(isStudentPassed).test(student1);
 System.out.println(result); //false
 // Testing if female student passed.
 Student student2 = new Student("Gauri", 19, "female", 40);
 result = isFemaleStudent.and(isStudentPassed).test(student2);
 System.out.println(result); //true
  }
}

3、or

在这里插入图片描述

3.1 说明

or是Predicate的默认方法，它返回一个组成的谓词，表示此谓词和其他谓词的短路逻辑OR。在评估组成的谓词时，如果此谓词为真，那么其他谓词将不会被评估。在错误的情况下，如果此谓词抛出错误，那么其他谓词将不会被评估。

3.2 例子

PredicateOrDemo.java

import java.util.function.Predicate;
public class PredicateOrDemo {
  public static void main(String[] args) {
 Predicate<Student> isMaleStudent = s -> s.getAge() >= 20 && "male".equals(s.getGender());
 Predicate<Student> isFemaleStudent = s -> s.getAge() > 18 && "female".equals(s.getGender());
 Predicate<Student> isStudentPassed = s -> s.getMarks() >= 33;
 // ---
 Student student1 = new Student("Mahesh", 22, "male", 35);
 //Test either male or female student
 Boolean result = isMaleStudent.or(isFemaleStudent).test(student1);
 System.out.println(result); //true
 //Is student passed, too
 result = isMaleStudent.or(isFemaleStudent).and(isStudentPassed).test(student1);
 System.out.println(result); //true
  }
}

4、negate()

在这里插入图片描述

4.1 说明

negate是Predicate的默认方法，它返回一个表示该谓词的逻辑否定的谓词。如果评估的结果是真的，negate将使它变成假的，如果评估的结果是假的，negate将使它变成真的。

4.2 例子

PredicateNegateDemo.java

import java.util.function.Predicate;
public class PredicateNegateDemo {
  public static void main(String[] args) {
       Predicate<Integer> isNumberMatched = n -> n > 10 && n < 20;
       //With negate()
       Boolean result = isNumberMatched.negate().test(15);
       System.out.println(result); //false
       //Without negate()
       result = isNumberMatched.test(15);
       System.out.println(result); //true
       // ---
       Predicate<String> isValidName = s -> s.length() > 5 && s.length() < 15;
       System.out.println(isValidName.negate().test("Krishna")); //false
       // ----
       Predicate<Integer> isLessThan50 = n -> n < 50;
       System.out.println(isLessThan50.negate().test(60)); //true
       // ----
       Predicate<Integer> isGreaterThan20 = n -> n > 20;
       System.out.println(isGreaterThan20.negate().test(30));  //false   
       // ----
       result = isLessThan50.and(isGreaterThan20).negate().test(25);
       System.out.println(result); //false
  }
}

5、isEqual

在这里插入图片描述

5.1 说明

isEqual是Predicate的静态方法，它返回测试两个参数是否等于Objects.equals(Object,
Object)的谓词。我们使用Predicate.isEqual创建predicate，如下所示。

Predicate<String> isHelloMsg = Predicate.isEqual("Hello");
Predicate<Book> isMahabharatBook = Predicate.isEqual(new Book("Mahabharat", "Vyas"));

5.2 例子

PredicateIsEqualDemo.java

import java.util.function.Predicate;
public class PredicateIsEqualDemo {
  public static void main(String[] args) {
    System.out.println("---Testing Hello message---"); 
    Predicate<String> isHelloMsg = Predicate.isEqual("Hello");
    System.out.println(isHelloMsg.test("Hello")); //true
    System.out.println(isHelloMsg.test("Hi"));  //false
    //  ----
    System.out.println("---Testing Mahabharat book---");
    Book mahabharatBook = new Book("Mahabharat", "Vyas");
    Predicate<Book> isMahabharatBook = Predicate.isEqual(mahabharatBook);
    System.out.println(isMahabharatBook.test(new Book("Mahabharat", "Vyas"))); //true
    System.out.println(isMahabharatBook.test(new Book("Ramayan", "Valmiki"))); //false
  }
}
class Book {
  private String name;
  private String writer;
  public Book(String name, String writer) {
 this.name = name;
 this.writer = writer;
  }
  public String getName() {
    return name;
  }
  public String getWriter() {
    return writer;
  }
  public boolean equals(final Object obj) {
    if (obj == null) {
        return false;
    }
    final Book b = (Book) obj;
    if (this == b) {
        return true;
    } else {
        return (this.name.equals(b.name) && (this.writer == b.writer));
    }
  }  
}

三、常用举例使用

在Stream流中使用Predicate
我们使用Stream.filter来过滤列表。

filter()的语法如下。

filter(Predicate predicate)

filter()在处理给定的Predicate后，返回由过滤后的数据组成的Stream实例。
例1：
PredicateStreamDemo1.java

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class PredicateStreamDemo1 {
  public static void main(String[] args) {
	List<String> list = new ArrayList<>();	
	list.add("Vijay");
	list.add("Ramesh");
	list.add("Mahesh");
	// ---
	Predicate<String> isNameEndsWithSh = s -> s.endsWith("sh");
	// ---
	list.stream().filter(isNameEndsWithSh)
	  .forEach(s -> System.out.println(s));
  }
}

输出：

Ramesh
Mahesh

例2：

PredicateStreamDemo2.java

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class PredicateStreamDemo2 {
  public static void main(String[] args) {
	List<Student> list = new ArrayList<>();
	list.add(new Student("Mahesh", 20, "male", 38));
	list.add(new Student("Gauri", 21, "female", 45));	
	list.add(new Student("Krishna", 19, "male", 42));
	list.add(new Student("Radha", 20, "female", 35));
	System.out.println("--- All students scoring marks > 40 ---");
	Predicate<Student> isScoreGt40 = std -> std.getMarks() > 40;
	filterStudent(isScoreGt40, list).forEach(s -> System.out.println(s));
	System.out.println("--- All Male Students ---");
	Predicate<Student> isMaleStudent = std -> "male".equals(std.getGender());
	filterStudent(isMaleStudent, list).forEach(s -> System.out.println(s));
	System.out.println("--- All Female Students ---");
	Predicate<Student> isFemaleStudent = std -> "female".equals(std.getGender());
	filterStudent(isFemaleStudent, list).forEach(s -> System.out.println(s));	
	System.out.println("--- All Female Students scoring > 40 ---");
	filterStudent(isFemaleStudent.and(isScoreGt40), list).forEach(s -> System.out.println(s));		
  }
  static List<Student> filterStudent(Predicate<Student> predicate, List<Student> list) {
	return list.stream().filter(predicate).collect(Collectors.toList());
  }
}

结果：

— All students scoring marks > 40 —
Gauri - 21 - female - 45
Krishna - 19 - male - 42
— All Male Students —
Mahesh - 20 - male - 38
Krishna - 19 - male - 42
— All Female Students —
Gauri - 21 - female - 45
Radha - 20 - female - 35
— All Female Students scoring > 40 —
Gauri - 21 - female - 45

借鉴文章

如有侵权请告知删除。

郭度自信

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Predicate接口的理解与应用

百度for谓词 Predicate ：用来代替或者展示其客体性质、特征或者客体之间关系的词项。根据《现代汉语》的定义,汉语的体词包括名词,数词,量词；汉语的谓词可以包括一切的例句。百度for客体：意思是指存在于主体之外的客观事物。也就是客观的描述，描述他是什么，例如有个数，你描述它是大于五的，其实这个数是不是大于5的还不知道。具体这个主体数是啥还得看你用什么进行填充。举例："猫是动物"一句中的"是"就是一个谓词，而"猫"是客体。“3 大于 2"中"大于"是一个谓词。
复制链接

扫一扫