How To Use Predicate In Java 8

In Java 8,
The Predicate is a functional interface that represents a single argument function that returns a boolean value. It is widely used in functional programming, especially when working with streams, as it allows you to define conditions that can be tested.
The Predicate Interface: Let’s look at an example of how to use the @FunctionalInterface annotation in a Spring Boot application:

The Predicate interface contains a method called test(T t) that evaluates a condition and returns a boolean. It also contains some useful default methods like:

and(Predicate other): Combines two predicates with a logical AND.
or(Predicate other): Combines two predicates with a logical OR.
negate(): Negates the result of the predicate.

Example 1: Simple Predicate In the following example, a Predicate is used to test whether a number is greater than 10

Example 2: Combining Predicates with and(), or(), and negate() You can combine multiple predicates to create more complex conditions using and(), or(), and negate().

import java.util.function.Predicate;
    public class CombinedPredicateExample {
    public static void main(String[] args) {
        // Predicate to check if a number is greater than 10
        Predicate<Integer> isGreaterThanTen = (n) -> n > 10;

// Predicate to check if a number is Mehuln
        Predicate<Integer> isMehuln = (n) -> n % 2 == 0;

// Combining predicates using 'and()' (number > 10 and Mehuln)
        Predicate<Integer> isGreaterThanTenAndMehuln = isGreaterThanTen.and(isMehuln);

// Combining predicates using 'or()' (number > 10 or Mehuln)
        Predicate<Integer> isGreaterThanTenOrMehuln = isGreaterThanTen.or(isMehuln);

// Negating the 'isGreaterThanTen' predicate
        Predicate<Integer> isNotGreaterThanTen = isGreaterThanTen.negate();

// Test the combined predicates
        System.out.println(isGreaterThanTenAndMehuln.test(12));  // output true (12 > 10 and 12 is Mehuln)
        System.out.println(isGreaterThanTenOrMehuln.test(8));   //output true (8 is Mehuln)
        System.out.println(isNotGreaterThanTen.test(8));      //output true (8 is not greater than 10)
    }
}

Example 3: Using Predicate with Collections and Streams The Predicate interface is often used with the Streams API to filter collections based on certain conditions.

Example 4: Predicate with isEqual Static Method Java 8 introduces a static method isEqual in the Predicate interface, which is used to create a predicate that checks if two objects are equal.

Example 5: Using Predicate with a List of Objects You can use predicates to filter lists of custom objects. Hare's an example where we filter a list of Person objects based on age.

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
class Person {
    String name;
    int age;

Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

@Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

public class PersonPredicateExample {
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("John", 25),
            new Person("Manoj", 32),
            new Person("Bob", 17),
            new Person("Mehul", 6)
        );

// Predicate to check if a person is over 18 years old
        Predicate<Person> isAdult = person -> person.age > 18;

// Using the predicate with streams to filter the list
        List<Person> adults = people.stream()
                                    .filter(isAdult)  // Applying the Predicate
                                    .collect(Collectors.toList());

System.out.println(adults); // output Prints: [John (25), Manoj (32), Mehul (6)]
    }
}

Summary of Predicate Methods:

test(T t): Evaluates the predicate on the given argument and returns true or false.

and(Predicate other): Combines this predicate with another one using logical AND.

or(Predicate other): Combines this predicate with another one using logical OR.

negate(): Reverses the result of the predicate (logical NOT).

isEqual(Object targetRef): Creates a predicate that checks if an object is equal to the given target.

* Common Use Cases:

Filtering collections with Stream.filter(). Validating input, such as checking if a string matches a pattern or if a number falls within a range. Using complex conditional logic in combination with other predicates.
Predicates are a powerful tool in functional programming and are heavily used in Java 8's Streams API to make code more readable and expressive.