Java Predicate Example
February 26, 2019
Predicate functional interface is introduced in Java 8. Java Predicate represents a predicate of one argument. A Predicate is a boolean-valued function. Java Predicate is a functional interface and belongs to java.util.function package. The functional method of Predicate is test(T t). The other methods of Predicate are test, isEqual, and, or, negate and not. The method not has been introduced in Java 11. Here on this page we will provide examples of Predicate with all its methods.
Contents
1. test(T t)
boolean test(T t)
test is the functional method of Predicate. It evaluates this predicate on the given argument.
Example-1:
PredicateTestDemo1.java
package com.concretepage;
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("Mahesh")); //true
// Is password valid
Predicate<String> isPasswordValid = p -> p != null && p.length() > 8 && p.length() < 15;
System.out.println(isPasswordValid.test("Mahesh123")); //true
// Word match
Predicate<String> isWordMatched = s -> s.startsWith("Mr.");
System.out.println(isWordMatched.test("Mr. Mahesh")); //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
PredicateTestDemo2.java
package com.concretepage;
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));
}
}
}
package com.concretepage;
import java.util.function.Function;
public class Student {
private String name;
private int age;
private String gender;
private int marks;
public Student(String name, int age, String gender){
this.name = name;
this.age = age;
this.gender = gender;
}
public Student(String name, int age, String gender, int marks){
this.name = name;
this.age = age;
this.gender = gender;
this.marks = marks;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getGender() {
return gender;
}
public int getMarks() {
return marks;
}
public String customShow(Function<Student,String> fun){
return fun.apply(this);
}
public String toString(){
return name+" - "+ age +" - "+ gender + " - "+ marks;
}
}
Hi, You are female and age 20
2. and(Predicate<? super T> other)
default Predicate<T> and(Predicate<? super T> other)
and is the default method of Predicate that returns a composed predicate that represents the short-circuiting logical AND of this predicate and the other predicate. When evaluating the composed predicate, if this predicate is false then other predicate will not be evaluated. In case of error, if this predicate throws error then other predicate will not be evaluated.
PredicateAndDemo.java
package com.concretepage;
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
}
}
false true
3. or(Predicate<? super T> other)
default Predicate<T> or(Predicate<? super T> other)
or is the default method of Predicate that returns a composed predicate that represents the short-circuiting logical OR of this predicate and the other predicate. When evaluating the composed predicate, if this predicate is true then other predicate will not be evaluated. In case of error, if this predicate throws error then other predicate will not be evaluated.
PredicateOrDemo.java
package com.concretepage;
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
}
}
true true
4. negate()
default Predicate<T> negate()
negate is the default method of Predicate that returns a predicate that represents the logical negation of this predicate. If the result of evaluation is true, negate will make it false and if the result of evaluation is false, negate will make it true.
PredicateNegateDemo.java
package com.concretepage;
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
}
}
false true false true false false
5. isEqual(Object targetRef)
static <T> Predicate<T> isEqual(Object targetRef)
isEqual is the static method of Predicate that returns the predicate that tests if two arguments are equal according to Objects.equals(Object, Object). We create predicate using Predicate.isEqual as following.
Predicate<String> isHelloMsg = Predicate.isEqual("Hello");
Predicate<Book> isMahabharatBook = Predicate.isEqual(new Book("Mahabharat", "Vyas"));
PredicateIsEqualDemo.java
package com.concretepage;
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"))); //true
}
}
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));
}
}
}
---Testing Hello message--- true false ---Testing Mahabharat book--- true false
6. not(Predicate<? super T> target)
static <T> Predicate<T> not(Predicate<? super T> target)
not is the static method of Predicate introduced in Java 11. not returns predicate that is the negation of supplied predicate. This is accomplished by returning result of the calling target.negate(). Find the example of Predicate.not.
PredicateNotDemo.java
package com.concretepage;
import java.util.function.Predicate;
public class PredicateNotDemo {
public static void main(String[] args) {
Predicate<Integer> isOdd = n -> n % 2 == 1;
Predicate<Integer> isEven = Predicate.not(isOdd);
System.out.println(isEven.test(10)); //true
Predicate<String> isNotHelloMsg = Predicate.not(Predicate.isEqual("Hello"));
System.out.println(isNotHelloMsg.test("Hi")); //true
System.out.println(isNotHelloMsg.test("Hello")); //false
}
}
true true false
Predicate with Stream
We will provide examples to usePredicate with Stream. We will filter list using Stream.filter. The syntax of filter() is as following.
filter(Predicate predicate)
filter() returns the instance of Stream that consists the filtered data after processing given Predicate.
Example-1:
PredicateStreamDemo1.java
package com.concretepage;
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
Example-2:
PredicateStreamDemo2.java
package com.concretepage;
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
