Tuesday, July 14, 2015

Hello Lamda

                                       From the beginning of java 8 release, We are hearing about something called lamda . Here i try to explain all that one should know about this mysterious thing called lamda which is one of the feature introduced in Java 8. For a functional programmer ( who uses different programming languages than java) , lamda expressions is something which they can relate to . A traditional object oriented java programmer will not expect such a feature to get introduced in Java. I will try to explain how lamda differs from object orientedness of java.
    Lets look at a case where we have to execute a piece of code multiple times . An example may be an ActionListener on a button click

// Defined using Inner classes

button.setOnAction(new EventHandler<ActionEvent>() {

   public void handle(ActionEvent event) {

      System.out.println("Thanks for clicking!");



     Here , The handle method is executed multiple times on each button click . This is an example of a code which is executed multiple times in an application . Same can be applied to a
Comparator which is passed to a Collections.sort method for sorting.  The compare method inside the defined comparator is called multiple times.Uptill now these kind of codes were passed as an object where a method is defined inside it . From now onwards we could pass it as a block of code, Which is to be executed .  This is more or less what lamda expressions are

  Lets look at it in detail.  Let me take the example of a String Comparator which does the comparison by length .  I will write the old way of doing it

   ArrayList<Strings> sortingNeeded = new ArrayList<String>();




   Collections.sort(sortingNeeded, LengthComparator);


   // LengthComparator code is defined as :


   class LengthComparator implements Comparator<String> {

   public int compare(String first, String second) {

      return Integer.compare(first.length(), second.length());



Lets now do it the Lamda way :

    ArrayList<Strings> sortingNeeded = new ArrayList<String>();



   // The block of code which needed to be executed here  is : Integer.compare(first.length(), second.length()) , 
//But since java is strongly typed, We have to provide the type of arguments as 
// well, So the code comes to be :


   Collections.sort(sortingNeeded, (String first, String second)-> Integer.compare(first.length(), second.length()) );

Whaat ?  isnt ?   Yes ,You have just seen one form of lambda expressions in Java: "parameters, the -> arrow, and an expression". . If the code carries out a computation that doesn’t fit in a single expression, write it exactly like you would have written a method: enclosed in {} and with explicit return statements. For example,

(String first, String second) -> {

   if (first.length() < second.length()) return -1;

   else if (first.length() > second.length()) return 1;

   else return 0;


Now you may be asking what if we have return  values , how do we specify the type of the return value . The answer is that you can never provide the return type , its always inferred from the context.

 Also if the type of the arguments can be inferred , You could avoid that too ,

  Comparator<String> comp = ( first,  second)-> Integer.compare(first.length(), second.length());

    here the type of first and second can be inferred from the context that it will be strings as the lamda function is assigned to a variable which is of the type string comparator. Hence we can avoid the type.

What if there is no argument type?
 yes , ()-> System.out.println("Hello")  is a valid  lamda expression .

 You are not at all expected to be clear about lamda expressions with this post . There will be a lot of questions , Where is this code executed ? What if an exception occurs  ? Where exactly do you use the lamda expressions . All this and much more on coming topics. Stay tuned.  Happy Coding :)


No comments:

Post a Comment