Java Lambda Expression Examples

Lambda expression in Java 8, enables to pass a functionality as a method argument. Lambda expressions is one of the hot topics in Java 8, which is about to be released. Few months back, I wrote article for introduction to Lambda expressions. In this article I will be presenting few examples using which we can understand Lamda expressions better. Needless to say, we need JDK 8 to work with lambda expressions and I used JDK 1.8 b115 Early Access Release.

1. Lambda Expression Hello World

This is a basic usage of lambda expression. HelloWorld is in an interface and on the fly at main method, we are providing a in implementation for that interface. After implementation, we use that instance and invoke its single methods. There will be always only one method and so the lambda expression need not specify the method name.

package com.javapapers.java8;

public class LambdaHelloWorld {
	interface HelloWorld {
		String hello(String name);
	}

	public static void main(String[] args) {	      
		 HelloWorld helloWorld = (String name) -> { return "Hello " + name; };
		 System.out.println(helloWorld.hello("Joe"));
	}
}

2. Accessing Local and Class Variables in Lambda Expression

This is another basic level code showing how we can access the local and class level variables in a lambda expression. Also note how we have passed reference for the Runnable.

package com.javapapers.java8;

public class LambdaVariableAccess {
	public String wildAnimal = "Lion";

	public static void main(String[] arg) {
		new LambdaVariableAccess().lambdaExpression();
	}

	public void lambdaExpression(){
        String domesticAnimal = "Dog";
        
        new Thread (() -> {
            System.out.println("Class Level: " + this.wildAnimal);
        	System.out.println("Method Level: " + domesticAnimal);
       }).start();        
    }
}

3. Function Argument in Lambda Expression

Slightly getting advanced with this example. We have got couple of implementations for the circle interface and they two different operations with respect to context. Those anonymous class implementations itself are passed as argument to another generic method, thus achieving a level of generic function.

package com.javapapers.java8;

public class LambdaFunctionArgument {

	interface Circle {
		double get(double radius);
	}

	public double circleOperation(double radius, Circle c) {
		return c.get(radius);
	}

	public static void main(String args[]){
		LambdaFunctionArgument reference = new LambdaFunctionArgument();
		Circle circleArea = (r) -> Math.PI * r * r;
		Circle circleCircumference = (r) -> 2 * Math.PI * r;
		
		double area = reference.circleOperation(10, circleArea);
		double circumference = reference.circleOperation(10, circleCircumference);
	
		System.out.println("Area: "+area+" . Circumference: "+circumference);
	}
}

4. Lambda Initialization

package com.javapapers.java8;

import java.util.concurrent.Callable;

public class LambdaInitialization {
	public static void main(String args[]) throws Exception{
		Callable[] animals = new Callable[]{()->"Lion", ()->"Crocodile"};
		
		System.out.println(animals[0].call());
	}
}

5. Lambda Expression Sorting

In this example the key is we are passing a method reference to another method call. The comparator implementation is passed to Arrays.sort as argument.

package com.javapapers.java8;

import java.util.Arrays;

public class LambdaExpressionSort {
	public static void main (String[] ar){
	        Animal[] animalArr = {
	        		new Animal("Lion"), 
	        		new Animal("Crocodile"), 
	        		new Animal("Tiger"), 
	        		new Animal("Elephant")};
	        
	        System.out.println("Before Sort: "+Arrays.toString(animalArr));
	        Arrays.sort(animalArr, Animal::animalCompare);
	        System.out.println("After Sort: "+Arrays.toString(animalArr));
	    }
}

class Animal {
	String name;

	Animal(String name) {
		this.name = name;
	}

	public static int animalCompare(Animal a1, Animal a2) {
		return a1.name.compareTo(a2.name);
	}
	
	public String toString() {
		return name;
	}
}

6. Predicates and Lambda Expressions

Predicates mixes well with the lambda expressions. We can have a generic implementation and pass predicate as argument in lambda expression. Based on the condition, operation is performed inside the lambda implementation.

package com.javapapers.java8;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class LambdaPredicate {
	
	public static int add(List numList, Predicate predicate) {
	    int sum = 0;
	    for (int number : numList) {
	        if (predicate.test(number)) {
	            sum += number;
	        }
	    }
	    return sum;
	}
	
	public static void main(String args[]){
		
		List numList = new ArrayList();
		
		numList.add(new Integer(10));
		numList.add(new Integer(20));
		numList.add(new Integer(30));		
		numList.add(new Integer(40));		
		numList.add(new Integer(50));
		
		System.out.println("Add Everything: "+add(numList, n -> true));
		System.out.println("Add Nothing: "+add(numList, n -> false));
		System.out.println("Add Less Than 25: "+add(numList, n -> n < 25));		
		System.out.println("Add 3 Multiples: "+add(numList, n -> n % 3 == 0));
	}
}