Java Functional Programming : 4. Consumer

-
This is the multi part series on Java Functional Programming

4. Consumer


The Consumer interface has a default method – andThen. It is used for chaining multiple Consumer objects.

Category
Consumer
Interface Definition
Consumer<T>
Abstract Method
void accept (T t)
Default Method
Consumer<T> andThen(Consumer<? super T> after)

Let’s look at the body of the default andThen method. It looks like this.


       default Consumer<T> andThen(Consumer<? super T> after) {
              Objects.requireNonNull(after);
              return (T t) -> { accept(t); after.accept(t); };
       }

The andThen method takes in a lambda expression as an input, executes the accept method and returns back the lambda expression. Taking the same example of the chair, here is how the method can be used.

      
Chair chair = Chair.createChair("My Brand", 100, true);
                          
Consumer<Chair> prBrand = (c) -> System.out.println(c.getBrand());
Consumer<Chair> prCost  = (c) -> System.out.println(c.getPrice());
//wholesale cost is 80% of the cost
Consumer<Chair> prWsCost = (c) -> System.out.println(Math.round(0.8*c.getPrice()));
             
// the andThen method chains multiple functionalities
// which can be executed at ones.
// Note that the input to the function is a lambda expression
prBrand.andThen(prCost).andThen(prWsCost).accept(chair);

When this code is executed, then the method is executed in the same order as defined. This is what gets printed on the console.
Chair Created ... !!
My Brand
100
80

The first line comes from creating the “Chair” and not by any lambda expression. This way, complex functionalities can be broken into smaller parts and chained. We could have defined all the three functionalities in a single lambda expression giving the same result. But I guess you’d have guessed by now, that this has an advantage of the order. You can order the functionalities according to your will, and maybe omit a few based upon the need of the program. This could help in organizing the program by functionalities and choose them within the methods based upon parameters or functional requirements.

<< Prev (The java.util.function Library) | Next (Predicate) >>

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