Java Functional Programming : 5. Predicate

-
This is the multi part series on Java Functional Programming

5. Predicate


The Predicate is used for making a Boolean check. Apart from the abstract method test it has 1 static and 3 default methods.


Category
Predicate
Interface Definition
Predicate<T>
Abstract Method
boolean test(T t)
Static Method
<T> Predicate<T> isEqual(Object targetRef)
Default Method 1
Predicate<T> and(Predicate<? super T> other)
Default Method 2
Predicate<T> or(Predicate<? super T> other)
Default Method 3
Predicate<T> negate( )

Let us first see how the body of each method looks. The three default methods – and, or and negate actually represent the logical checks - AND, OR and NOT. Since these return a Predicate these can be chained too just like the Consumer we saw earlier. It is not a good idea to chain too many operators as they may add to confusion. The logical step should be to add intermediate predicates and evolve the operation step by step by combing two or three predicates at a time.

                                        
       default Predicate<T> and(Predicate<? super T> other){
               Objects.requireNonNull(other);
               return (t) -> test(t) && other.test(t);
       }
                          
       default Predicate<T> or(Predicate<? super T> other){
              Objects.requireNonNull(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
                           : object -> targetRef.equals(object);
       }

The method and does a logical AND operation between two predicates. The methods negate and or do the logical operations as their name suggests. The beauty is that they can be joined as a chain.


Chair chair = Chair.createChair("My Brand", 200, true);
      
Predicate<Chair> isExpensive = (c) -> c.getPrice() > 100;
Predicate<Chair> isCushioned = (c) -> c.isWithCushion();
             
// is Expensive AND Cushioned?
boolean isExpAndCushioned = isExpensive.and(isCushioned).test(chair);
System.out.println("isExpAndCushioned=" + isExpAndCushioned);
             
// is NOT expensive
boolean isNotExpensive = isExpensive.negate().test(chair);
System.out.println("isNotExpensive=" + isNotExpensive);
             
// is NOT expensive OR NOT cushioned
boolean isNotExOrNotCush = isExpensive.negate().or(isCushioned.negate()).test(chair);
System.out.println("isNotExOrNotCush=" + isNotExOrNotCush);
             
// the isEqual static method gives back a predicate
// this can be used to test equality with other Chair
Chair chair2 = Chair.createChair("My Other Brand", 200, true);
Predicate<Chair> isEqual = Predicate.isEqual(chair2);
boolean isSame2 = isEqual.test(chair);
System.out.println("isSame Chair2=" + isSame2);
             
Chair chair3 = Chair.createChair("Brand 3", 200, false);
boolean isSame3 = isEqual.test(chair3);
System.out.println("isSame Chair3=" + isSame3);

This is what gets printed when we execute the above code.

Chair Created ... !!
isExpAndCushioned=true
isNotExpensive=false
isNotExOrNotCush=false
Chair Created ... !!
isSame Chair2=true
Chair Created ... !!
isSame Chair3=false

Check that the isEqual actually invokes equals method defined in the Chair class.


<< Prev (Consumer) | Next (Function) >>

Comments

Post a Comment

Popular posts from this blog

Java Generics - 7. Upper and Lower Bounds

-
Image
This is part 7 of the 9 part series on Java Generics  Prev Topic Typed Classes as method parameters Topics 1. Introduction 2. Bounding 3. Multiple bounding 4. Generic Methods 5. Wildcards 6. Typed Classes as method parameters 7. Upper and Lower Bounds 8. Target Types 9. Type Erasure Next Topic Target Types Java Generics - Upper and Lower Bounds This is going to be a really long blog, so please bear with me. Declaring Generic Variables You can also use generics to declare the variables. In other work you can choose which types can be assigned to a variable. The rules are more or less the same as for methods. You cannot define a type variable, like you could for the methods. Thus the declaration below makes no sense.         // invalid        private <E extends Fruit> E var1 = null ;      ...
Read more

Java Functional Programming : 3. The java.util.function Library

-
Image
This is the multi part series on Java Functional Programming 3. The java.util.function Library In most cases you might not need to declare your own functional interface as Java gives you a standard set of interfaces to save your time. In case you’d like to work with a function of two parameters of the same type, you could probably use the interface java.util.function.BinaryOperator<T> for the same activity. (More on the package java.util.function is to follow). As a shortcut, you’d probably prefer to keep things simple without the need of an extra interface declaration. Lets look at the constructs below:        BinaryOperator<Integer> binAdd = ( a , b ) -> a + b ;        System. out .println( "Bin Add 2, 3 = " + binAdd .apply(2, 3)); The lambda expressions can be passed as a parameter into the methods. Let us define a method which doubles the value given by the lambda ex...
Read more

Java Generics - 3. Multiple bounding

-
Image
This is part 3 of the 9 part series on Java Generics  Prev Topic Bounding Topics 1. Introduction 2. Bounding 3. Multiple bounding 4. Generic Methods 5. Wildcards 6. Typed Classes as method parameters 7. Upper and Lower Bounds 8. Target Types 9. Type Erasure Next Topic Generic Methods Java Generics - Multiple bounding Refer back to out Fruit and Grain hierarchy. Remember few of the Grains and Fruits also implement the interface Exportable . What if you wanted the generic class to be used only with the type Exportable? We already discussed that earlier. The declaration extends makes no distinction whether the F extends a class or an interface. The generics give us even more flexibility. Say you wanted you generic class to be used with a type Fruit which is Exportable ? Here the class to be used with the Generic types should be both – Fruit & Exportable . Is that possible with generics? Yes of cou...
Read more