Lambda Expressions

Java is not the first language to introduce Lambda expressions as we have languages like C#, Ruby, Scala, JavaScript etc. support lambda expressions already. In some languages like C++ lambda expressions are supported only in the recent version (C++ 11). Overall lambda expressions are here to stay. So understanding them is a must.

What is Lambda Expression?

Lambda expression can be used where we have to implement an interface with single abstract method. Since Java 8 an interface can have non-abstract methods also. So lambda can replace the implementation of an interface with only one abstract method.

Let's just look at basic syntax of lambda before working with some examples.

  (parameters) ->  expression
  (parameters) ->  { // block of code }

In the first syntax, expression is what we want to execute and whatever value it results in is the return value of the function.

In the second syntax, where we use a block of code, we need to explicitly return a value if function has to return a value. If function that lambda replaces doesn't return a value then block of code need not have a return statement.

What is Functional Interface?

Since Java 8 supports non-abstract methods in interface, any interface that has single abstract method with or without other kinds of methods like default and static methods is called functional interface.

In order to ensure an interface matches functional interface definition we can use @FunctionalInterface annotation with an interface.

Method Reference

  Class::methodname  
  Object::methodname

The following example shows how to use Anonymous inner class, Lambda expression and Method reference.

 @FunctionalInterface 
 public interface Printable<T> {
    void print(T v);
    default void printLine(int size) {
        for(int i =1; i <=size; i ++)
              System.out.print('-');
    }
 }

Implementing Interface without lambda

 // Anonymous inner class example
 Printable<String> p1 = new Printable<String>() {
   @Override
   public void print(String v) {
    System.out.println(v);
   } 
 };
 p1.print("Anonymous Inner Class");

Using Lambda Expression

  Printable<String> p2 = (String v) -> System.out.println(v);
  p2.print("Lambda expression");

  Printable<String> p2 = (v) -> System.out.println(v);
  p2.print("Lambda expression");

As lambda expression is calling function println(), it is possible to replace the lambda expression with method reference as follows:

  Printable<String> p3 = System.out::println;
  p2.print("Lambda Expression With Method Reference");

Multithreading Code without Lambda

In order to create a thread, we need to first implement run() method that is part of Runnable interface, which is one of the functional interfaces in Java library. First let's see a program in which we use anonymous inner class to implement Runnable interface.

 public class MultiThreadingJava7 {
     public static void main(String[] args) {
         Runnable task = new Runnable() {
             public void run() {
                 for (int i=1;i <=10; i++)
                      System.out.println(i);
             }
         };
         Thread t = new Thread(task);
         t.start();
     }
 }

 public class MultiThreadingJava8 {
    public static void main(String[] args) {
        Runnable task = () -> {
              for (int i=1;i <=10; i++)
                System.out.println(i);
         };
         Thread t = new Thread(task);
         t.start();
    }
 }

Using Lambda Expression for Comparator

public class MyTime {
    private int hours, mins, secs;
    public MyTime(int hours, int mins, int secs) {
        this.hours = hours;
        this.mins = mins;
        this.secs = secs;
    }
    @Override
    public String toString() {
        return  String.format("%02d:%02d:%02d", hours, mins, secs);
    }     
    public int totalSeconds() {
        return  hours * 3600 + mins * 60 + secs;
    }
}

import java.util.ArrayList;

public class LambdaWithMyTime {
    public static void main(String[] args) {
         ArrayList<MyTime> times  = new ArrayList<MyTime>();
         times.add( new MyTime(10,34,30));
         times.add( new MyTime(14,15,20));
         times.add( new MyTime(7,10,50));
    
         // sort times with Lambda expression 
         times.sort((t1,t2) -> t1.totalSeconds() - t2.totalSeconds());
         times.forEach(t -> System.out.println(t));
    
         // using lambda expression 
         times.removeIf(t -> t.totalSeconds() > 3600);
    }
}

Java 8 added new methods to List interface in collection framework. Two of the new methods used in the above program have the following signatures.

 removeIf(Predicate<T>)
 forEach(Consumer<T>)

Conclusion