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:
@FunctionalInterface public interface Predicate<T> { boolean test(T t); // Other default methods default Predicate<T> and(Predicate<? super T> other) { return (t) -> test(t) && other.test(t); } default Predicate<T> or(Predicate<? super T> other) { return (t) -> test(t) || other.test(t); } default Predicate<T> negate() { return (t) -> !test(t); } static <T> Predicate<T> isEqual(Object targetRef) { return (null == targetRef) ? Objects::isNull : targetRef::equals; } }
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
import java.util.function.Predicate; public class PredicateExample { public static void main(String[] args) { // Define a Predicate to check if a number is greater than 10 Predicate<Integer> isGreaterThanTen = (n) -> n > 10; // Test the Predicate with different values System.out.println(isGreaterThanTen.test(5)); // output false System.out.println(isGreaterThanTen.test(15)); // output true } }
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.
import java.util.Arrays; import java.util.List; import java.util.function.Predicate; import java.util.stream.Collectors; public class PredicateWithStreamExample { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // Predicate to check if a number is Mehuln Predicate<Integer> isMehuln = (n) -> n % 2 == 0; // Using the 'filter' method in Stream with Predicate List<Integer> MehulnNumbers = numbers.stream() .filter(isMehuln) // Applying the Predicate .collect(Collectors.toList()); System.out.println(MehulnNumbers); // Output Prints: [2, 4, 6, 8, 10] } }
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.
import java.util.function.Predicate; public class PredicateIsEqualExample { public static void main(String[] args) { Predicate<String> isHello = Predicate.isEqual("Hello"); System.out.println(isHello.test("Hello")); // Output true System.out.println(isHello.test("World")); // Output false } }
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.