Predicate and Consumer Interface in java.util.function package in Java 8

In my previous post I wrote about Function interface which is part of java.util.package. I also mentioned about Predicate interface which is part of the same package and in this post I will show you how you can make use of the Predicate and Consumer interfaces.

Lets look at the Javadoc for Predicate interface:

Determines if the input object matches some criteria.

And there are 5 methods declared/defined in that interface (you must be wondering how this is a functional interface, if you are then you must read this before proceeding) and those methods are:
//Returns a predicate which evaluates to true only if this predicate
//and the provided predicate both evaluate to true.
and(Predicate<? super T> p)

//Returns a predicate which negates the result of this predicate.

//Returns a predicate which evaluates to true if either
//this predicate or the provided predicate evaluates to true
or(Predicate<? super T> p)

//Returns true if the input object matches some criteria
test(T t)

//Returns a predicate that evaluates to true if both or neither
//of the component predicates evaluate to true
xor(Predicate<? super T> p)
All of the methods except test(T t) are default methods and test(T t) is abstract. One approach of providing the implementation for this abstract method is to use Anonymous inner class and the other approach is to use lambda expression.

The Javadoc for Consumer interface states:

An operation which accepts a single input argument and returns no result. Unlike most other functional interfaces, Consumer is expected to operate via side-effects.

There are 2 methods in this interface out of which only one is abstract and that abstract method is: accept(T t), which accepts an input and doesn’t return any result.

To explain more about Predicate and Consumer interface lets consider a Student class with name, grade and fee to be paid. Each student has some discount which is decided based on the Student’s grade.
class Student{
String firstName;
String lastName;
Double grade;
Double feeDiscount = 0.0;
Double baseFee = 20000.0;

public Student(String firstName, String lastName,
Double grade) {
this.firstName = firstName;
this.lastName = lastName;
this.grade = grade;

public void printFee(){
Double newFee = baseFee – ((baseFee*feeDiscount)/100);
System.out.println("The fee after discount: "+newFee);

And lets create a method which accepts a Student object, a Predicate implementation and a Consumer implementation. If you are not familiar with Function interface, then you should spent few minutes reading this. This method uses the predicate to decide if the student discount on the fee has to be updated and then uses the Consumer implementation to update the discount.
public class PreidcateConsumerDemo {

public static Student updateStudentFee(Student student,
Predicate<Student> predicate,
Consumer<Student> consumer){

//Use the predicate to decide when to update the discount.
if ( predicate.test(student)){
//Use the consumer to update the discount value.
return student;

Both the test method and the accept method in the Predicate and Consumer respectively accept a parameter of the generic type declared. The difference between these is that the predicate uses the parameter to make some decision and return a boolean whereas Consumer uses the parameter to change some of its value.
Lets look at how the updateStudentFee method is invoked:
public static void main(String[] args) {

Student student1 = new Student("Ashok","Kumar", 9.5);
student1 = updateStudentFee(student1,
//Lambda expression for Predicate interface
student -> student.grade > 8.5,
//Lambda expression for Consumer inerface
student -> student.feeDiscount = 30.0);

Student student2 = new Student("Rajat","Verma", 8.0);
student2 = updateStudentFee(student2,
student -> student.grade >= 8,
student -> student.feeDiscount = 20.0);


In this post I explained with a sample how we can make use of Predicate and Consumer interfaces which are part of the java.util.function package to be introduced in Java 8.


3 thoughts on “Predicate and Consumer Interface in java.util.function package in Java 8

  1. Pingback: Supplier interface in java.util.function package in Java 8 | Experiences Unlimited

  2. Pingback: Train Wreck Pattern – A much improved implementation in Java 8 | Java, JVM and beyond

  3. Pingback: Deep dive into Optional class API in Java 8 | Java, JVM and beyond

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s