Predicate In Java 8 with examples | test(), and(), or(), negate() methods

 

What is Predicate in Java 8? 

• Predicate in general meaning is a statement about something that is either true or false. In programming, predicates represent single argument functions that return a boolean value.

• Predicate is a functional interface representing a single argument function that returns a boolean value.

• If we want conditional check in our code, we can use Predicate.  

Predicates in Java are implemented with interfaces. Predicate<T> is a generic functional interface representing a single argument function that returns a boolean value. It is located in the java.util.function package. It contains a Test (T t) method that evaluates the predicate on the given argument.

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

test is only abstract method present in Predicate interface. It is return boolean value based on given condition.

With predicates, we can create code that is more clean and readable. Predicates also help to create better tests.

Lets understand Predicate using code.

Example 1 : Without Predicate interface

public class PredicateDemo {
    
    public boolean checkNumber(int number) {
        if (number > 18) {
            return true;
        } else {
            return false;
        }
    }
    
    public static void main(String[] args) {
        
        PredicateDemo obj = new PredicateDemo();
        System.out.println(obj.checkNumber(17));
        System.out.println(obj.checkNumber(22));
        
    }
    
} 
Output :
false
true

Example 2 : With Predicate interface

import java.util.function.Predicate; 
public class PredicateDemo {
    
    public static void main(String[] args) {
        
        Predicate<Integer> predicate = number -> number > 18;
        System.out.println(predicate.test(17));
        System.out.println(predicate.test(22));
        
    }
}

Example 3 : Check even number or not using Predicate interface

public class PredicateDemo {
    
    public static void main(String[] args) {
        
        Predicate<Integer> isEven = number -> number % 2 == 0;
        System.out.println("Number 17 is even number : "+ isEven.test(17));
        System.out.println("Number 22 is even number : "+ isEven.test(22));
        
    }
    
}
Output :
Number 17 is even number : false
Number 22 is even number : true

Methods of Predicate :

1. boolean test() - abstract method
2. and() - default method
   
3. negate() - default method
   
4. or() - default method
   
5. isEqual() - static method

test :

Evaluates this predicate on the given argument.

and :

Returns a composed predicate that represents a logical AND. When evaluating the composed predicate, if this predicate is false, then the other predicate is not evaluated.

or :

Returns a composed predicate that represents a logical OR. Return true if any condition becomes true in given predicate.

negate :

Returns a predicate that represents the logical negation of this predicate. It is return opposite of given condition.

isEqual :

It returns a predicate that tests if two arguments are equal according to Objects.equals(Object, Object).

Example 4 : Predicate or() method 

import java.util.function.Predicate;
import java.util.List;
import java.util.Arrays;
import java.util.stream.Collectors;

public class PredicateDemo {
    
    public static void main(String[] args) {
        
        List<String> techCompanies = Arrays.asList("Google", "Amazon", "Flipkart", "Apple");

        Predicate<String> predicatenameLength = 
              company -> company.length() == 5;

        Predicate<String> predicateEndsWith = 
              company -> company.endsWith("le");

        List<String> afterPredicateList = techCompanies.stream()
        .filter(predicatenameLength.or(predicateEndsWith))
        .collect(Collectors.toList());

        System.out.println(afterPredicateList);
        
    }
    
}
Output :
[Google, Amazon, Apple]

In above output, Amazon is return by predicatenameLength and Google and Apple return by predicateEndsWith predicate.

Example 5 : Predicate and() method

public class PredicateDemo {
    
    public static void main(String[] args) {
        
        List<Integer> numbersList = 
                  Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        Predicate<Integer> predicteNumberGT3 = 
             number -> number > 3;
         Predicate<Integer> predicteNumberLT9 = 
              number -> number < 9;

        List<Integer> afterPredicateList = numbersList.stream()
        .filter(predicteNumberGT3.and(predicteNumberLT9))
        .collect(Collectors.toList());
 
        System.out.println(afterPredicateList);
        
    }
    
}
Output :
[4, 5, 6, 7, 8]

In and() predicate, if both condition are satisfy then it return true.

Example 6 : Predicate negate() method

public class PredicateDemo {

    public static void main(String[] args) {

         List<String> techCompanies = 
                Arrays.asList("Google", "Amazon", "Flipkart", "Apple");

         Predicate<String> predicatenameLength = 
               company -> company.length() == 5;

         List<String> afterPredicateList = techCompanies.stream()
         .filter(predicatenameLength.negate())
         .collect(Collectors.toList());

         System.out.println(afterPredicateList);
    }
}

Output:
[Google, Amazon, Flipkart]

In above example, we are returning companies whose length is == 5, but it is negate() predicate so it is returned opposite of that. means it returns companies whose length is not 5. 

Advantages of  Predicate :-

• Predicate classes are easy to test and change.
• Your domain objects remain clean and focused on representing your domain, not your business logic.
• You optimize the re-usability of your code and, in the end, reduce your maintenance.
• You separate your business from operational concerns.

 

Other Java 8 articles :

• Lambda Expression in Java 8 
• Consumer and BiConsumer In Java 8