Predicate Functional Interface In Java 8 With Example

In implementing Lambda Expression we need a Functional Interface that’s why a Predefined Function Interface is given by Java People from Java 8 onwards. This is available in the “java.util.function” package. A predefined Functional Interface is making Lambda Expression used in a common coding activity. Predicate Predefined Functional Interface is used for conditional check and returns a boolean result as an output.

Prototype:

interface Predicate<T>{
public boolean test(T t);

}

T – It is the type of input to the predicate.

Example:

import java.util.function.Predicate;

public class Test {

  public static void main(String[] args) {

    Predicate < Integer > p = i -> i % 2 == 0;

    System.out.println("Is No. Even: " + p.test(10));

    System.out.println("Is No. Even: " + p.test(15));

    System.out.println("Is No. Even: " + p.test(20));

    System.out.println("Is No. Even: " + p.test(5));

  }
}

In the above example, we can check if the input number is even or not by using Predicate.
See the lines of code are reduced than without implementation of Lambda expression.

Output:

Is No. Even: true
Is No. Even: false
Is No. Even: true
Is No. Even: false

Example:

import java.util.function.Predicate;

public class Test {

  public static void main(String[] args) {

    String[] s = {
      "Ramesh",
      "Ravi",
      "Raju",
      "Raghav",
      "Dinesh"
    };

    Predicate < String > p = s1 -> s1.length() > 5;

    for (String name: s) {

      if (p.test(name)) {

        System.out.println(name);

      }
     }
   }
}

In the above example, we can check String length is greater than five by using Predicate.

Output:

Ramesh
Raghav
Dinesh

Example:

package test;

import java.util.ArrayList;

import java.util.List;

import java.util.function.Predicate;

class Student {

  String name;

  int marks;

  public Student(String name, int marks) {

    this.name = name;

    this.marks = marks;

  }

}

public class Test {

  public static void main(String[] args) {

    List < Student > listStudnt = new ArrayList < Student > ();

    listStudnt.add(new Student("Raj", 70));

    listStudnt.add(new Student("Vineet", 60));

    listStudnt.add(new Student("Raghav", 40));

    listStudnt.add(new Student("Sham", 30));

    listStudnt.add(new Student("Dinesh", 50));

    Predicate < Student > p = stu -> stu.marks > 40;

    for (Student stdnt: listStudnt) {

      if (p.test(stdnt)) {

        System.out.println("Name: " + stdnt.name + " Marks: " + stdnt.marks);

      }
    }
  }
}

In the above example, we can use Predicate in our class.
We also achieve this task through an “ if ” conditional check. But in future we are required to check more conditions then we have to perform more time in the “ if ” conditional check that’s why it is better to use Predicate and save all conditions into Predicate.

Output:

Name: Raj Marks: 70
Name: Vineet Marks: 60
Name: Dinesh Marks: 50

If we want to check whether the number is even or not and also check whether the number is greater than 10. In this type of conditional checking by using a Predicate we need two Predicates like
p1—>checking for an even number
p2—>checking for numbers greater than 10
We achieve this from Predicate Joining like:
p1.and(p2).test(20)

Predicate Joining:

Multiple Predicates are combined to check complex conditional expressions. This is called Predicate Joining.

p1.and(p2)————Satisfies both conditions
p1.or(p2)—————Satisfies one condition or other
p1.negate()————–Opposite of p1

Example:

import java.util.function.Predicate;

public class Test {

public static void main(String[] args) {

int[] n = { 6, 8, 30, 25, 30, 45, 40, 50 };

Predicate<Integer> p1 = i -> i % 2 == 0;

Predicate<Integer> p2 = i -> i >=10;

System.out.println("The numbers are:");

for (int n1 : n) {

if (p1.and(p2).test(n1)) {

System.out.println(n1);
     }
  }
 }
}

In the above example, we can check whether the number is even and greater than or equal to 10 by using Predicate Joining.

Output:

The numbers are:
30
30
40
50

Example:

import java.util.function.Predicate;

public class Test {

public static void main(String[] args) {

int[] n = {5,6, 8, 25, 30, 45, 40, 50 };

Predicate<Integer> p1 = i -> i % 2 == 0;

Predicate<Integer> p2 = i -> i >=10;

System.out.println("The numbers are:");

for (int n1 : n) {

if (p1.or(p2).test(n1)) {

System.out.println(n1);

}
}
}
}

In the above example, we can check whether the number is even or greater than equal to 10 by using Predicate Joining.

Output:

The numbers are:
6
8
25
30
45
40
50

Example:

import java.util.function.Predicate;

public class Test {

public static void main(String[] args) {

int[] n = {5,6, 8, 25, 30, 45, 40, 50 };

Predicate<Integer> p1 = i -> i % 2 == 0;

System.out.println("The numbers which are not even:");

for (int n1 : n) {

if (p1.negate().test(n1)) {

System.out.println(n1);

}
}
}
}

In the above example, we can check the number is not even by using Predicate Joining.

Output:

The numbers which are not even:
5
25
45

Conclusion:

This topic is explained What is Predicate? How to use Predicate? What is Predicate Joining? How to use Predicate Joining?

What is Predicate Functional Interface in Java 8

Predicate Joining:

Leave a Comment Cancel reply