What is Predicate in Java 8?

The Predicate in Java 8 is one of the types of Functional Interfaces. Functional Interfaces were introduced in Java 8 to support functional programming in the object-oriented world of Java. The Predicate is one of them, which allows programmers to test a specific condition imposed on values or objects. Such a condition will always return a boolean value.

To understand better what is Predicate interface, you must first understand what the word "predicate" mean. The term "predicate" implies a statement that evaluates whether a value is true or false.

The next thing that you need to understand is Functional Interface. Functional Interface is nothing but just an interface with a "single abstract method", also commonly termed as SAM. They are annotated with @FuctionalInterface annotation. These interfaces also act as a target type for lambda expressions.

When to Use Predicates?

1. Code reusability in unit-testing
2. For tasks involving item evaluation based on predefined criteria.
3. To apply filter for a collection of objects.

1. Code Reusability in Unit-Testing

By separating the conditions required for the checks, Predicates prove to be very helpful in unit-testing as they can be reused in different kinds of tests.

As you also saw in the above code, how Predicates combined with lambda expression result in a lot lesser code. So you can use Predicate in Java 8 to ensure that the code is easy to understand and manage because they have more readability than if-else checks.

2. Item Evaluation Based on Conditions

Wherever you feel there's a need to evaluate items (item could be a value or an object) that can result in true or false, you can use Predicates.

Scenarios like:

• Checking if the account balance is more than a certain amount for a specific type of account, say, a savings account.
• Checking if a person is eligible to vote.

and many more.

Practically, you can use Predicates wherever there are conditions to be checked.

3. Using Predicates as a Condition for Filtering for a Collection of Items

Let's say you have a bag full of fruits like Apples, Oranges, Mangoes, Guavas, etc. This bag can be considered a collection of fruits. Now, these fruits need to pass a test before you can eat them. An eatable fruit must be fresh and should weigh at least 75 grams. Such a test can be translated into Java language through Predicates. The Predicates stores this testing logic and applies it to a collection to filter it.

You can use Predicates in Java 8 to extract out specific values from a collection like:

• Extracting out odd numbers from a list of numbers.
• Employees that joined a company between certain dates.

and many other real life scenarios.

Java Predicate Interface Methods

There are handful of methods provided by the Predicate interface. These are:

Java Predicate Interface Examples

There are several places where Predicates can be used. Some of them include:

1. A Simple Predicate in Java 8

Output:

Explanation: This code defines a Predicate on integer values that tests if their value is less than 20. Predicate<Integer> is used to create Predicates that operate on integers. The lambda expression num -> num < 20 must be compatible with the type of variable it is assigned to i.e, it's body , num < 20 in this case, must test a condition on an integer and return a boolean value.

2. Predicate Chaining with "and" Method

Sometimes, conditions become complex when two or more conditions are to be checked simultaneously. In such a case, two or more Predicates can be chained together, and the resulting Predicate can be used to test a complex condition.

Output:

Explanation: The Predicate isAdult will store the check for ages more than or equal to 18. And, notASeniorCitizen Predicate stores the check for ages less than 60. The composed Predicate combinedPredicateForAge created through the and method stores a check that is logical AND of both conditions, i.e., ages more than or equal to 18 but less than 60.

3. Predicate Chaining with or Method

A similar Predicate chaining can also be done through the or method.

Output:

Explanation: The program creates two Predicates in Java 8 that operate on strings. startsWithA stores the check to test if they start with the letter 'A'. endsWithZ stores the check to test if they end with the letter 'Z'. The composed predicate generated with the or method will store the check for logical OR of both conditions, i.e., strings will only pass the test with startsWithAOrEndsWithZ (the composed Predicate) if either they start with the letter 'A' or end with the letter 'Z' or both.

4. Negating a Predicate by "negate" Method

This method is used on a Predicate to check for obtaining its negation i.e., a logically opposite Predicate.

Output:

Explanation: The Predicate line in above code is created to store the check for ages more than 18 but uses the negate method to reverse that check. Reversal of the test is equivalent to logical NOT of the condition, i.e., now ages less than or equal to 18 will return true. We have chained the Predicate with negate and directly tested the values without first storing the newly created Predicate, unlike in previous examples.

5. Checking Equality with Predicates in Java 8 Using "isEqual" Method

This type of Predicate, generated by the static method isEqual, is used to check if an object is equal to another object according to Object.equals(Object, Object)

Checking Equality for a Primitive Type

Output:

Explanation: The Predicate in the above code is used to check some string's equality with the string "PIE". isEqual is a static method of Predicate interface, so it is callable without creating any lambda expression beforehand. This is equivalent to Predicate<String> testStringEquality = str -> str == "PI". However, isEqual allows you to do so implicitly.

Checking Equality for an Object Created through a Custom Class that Overrides "equals" Method

Output:

Explanation: This example shows how the isEqual method works. It utilises Object.equals(Object, Object) method internally. The object referenced by p1 and the object passed to the Predicate (for checking the equality) are two different objects created in the Heap. But the equality test done through Predicate still gives a true value because the equals method is overridden in the Person class to check equality only for data members' values, not the object reference. If you didn't override the equals method, then the output would be false for both cases.

6. Predicate in Java 8 to Filter a Collection

The most common use of Predicates is found in filtering a collection of objects by creating a stream.

Output:

Explanation: startsWithb Predicate stores the check if strings start with the letter 'b'. hasLengthGreaterThan2 stores the check for strings that contain more than two letters. The composed Predicate in the example acts as a filter rule for a given list of strings. Such filter rules are accepted in the filter method.

Thus, Predicate chaining inside the filter method will result in a composed Predicate that stores a check for strings containing more than two letters starting with the letter 'b'.