Java 8 - Lambda Expressions

Introduction

With reference to the last article, Introduction to Java 8, Java 8 consists of various interesting features and one of them is Lambda Expressions.

Lambda Expressions means a block of code that you can pass around so it can be executed later, once or multiple times. A new operator is introduced to work with lambda expressions i.e -> operator.

Syntax to use lambda expressions : lambda operator -> body

Example : (int a, int b) - > a + b;

Why Lambda Expressions ?

Lambda expressions come into play as we had an issue while using anonymous* class; i.e its implementation is quite simple and similar as an interface that contains only one method, thus syntax seems to be unclear. Lambda expressions allow you to treat functionality as method argument or code as data and allow to express instances of single method classes more concisely.

Ideal Use Cases for Lambda Expressions

This article covers some Ideal Use Cases for Lambda Expressions which are explained below,

Create method that match one characteristic within members

A simple approach to create several methods and each method searches that particular match, this method will print the elements of the list with odd length.

package LambdaExpressions;
import java.util.Arrays;
import java.util.List;
public class LambdaDemo {
public static void main(String[] args) {
List < String > list = Arrays.asList("Abc@d", "Cde", "GGhi", "Km", "MLno", "OpDq", "Qrs", "Stu23");
//using lambda expression
list.forEach(i - > {
if (i.length() % 2 != 0) { //check for odd length of string
System.out.println(i);
}
});
}
}

More generalized search methods

This method is more generic than the last one, it prints elements which satisfy the below condition, as shown this method will print the element in the list which has odd length and which start with ‘A’ or ‘a’.

Here startsWith (prefix) is an inbuilt method under String class in Java.

package LambdaExpressions;
import java.util.Arrays;
import java.util.List;
public class LambdaDemo {
public static void main(String[] args) {
List < String > list = Arrays.asList("Abade", "Cde", "aFdfrfg", "aGhi", "AaIjk", "ALno", "apoDq", "Qrs", "Stu");
//using lambda expression
list.forEach(i - > {
if ((i.length() % 2 != 0) && (i.startsWith("A")) || (i.startsWith("a"))) //check for odd length of string
{
System.out.println(i);
}
});
}
}

Specify search criteria with Local Class

This method will simply print the elements of the arraylist, the method checks for each element of the list with the help of reference variable cons of consumerImplementclass.

Thus, the reference variable automatically identifies the datatype of the element and processes it further for desired output.

Here Consumer<T> is a functional interface with only one abstract method i.e publicvoidaccept(T t) which accepts an integer value and prints that value to console.

Interface Consumer<T>
{
void accept(T t);
}

Whole code will look like this,

package LambdaExpressions;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
//Consumer<Integer> is a functional interface with only one abstract method.
class consumerImplement implements Consumer < Integer > {
@Override
public void accept(Integer i) {
System.out.println(i);
}
}
public class localClassSearch {
public static void main(String[] args) {
List < Integer > list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
Consumer < Integer > cons = new consumerImplement();
list.forEach(cons); //will print the elements of ArrayList
}
}

Specify search criteria with Anonymous Class

An anonymous class enables us to make our code more concise. It allows us to declare and instantiate class simultaneously. Here, in the code below we have used an anonymous class concept where we don’t need to define the method inside the interface, we have to introduce that class and parameters at time of object creation.

//Interface
interface parser {
String parse(String str);
}
class StringParser {
public static String convert(String str) {
if (str.length() <= 3) {
str = str.toUpperCase();
} else {
str = str.toLowerCase();
}
return str;
}
}
class MyPrinter {
public void print(String str, parser p) {
str = p.parse(str);
System.out.println(str);
}
}
public class anonymousClassSearch {
public static void main(String[] args) {
String str = "Aman Gupta";
MyPrinter mp = new MyPrinter();
// Using Anonymous Class
mp.print(str, new parser() {
public String parse(String str) {
return StringParser.convert(str);
}
});
}
}

Specify search criteria with Lambda Expression

In this, Consumer<Integer> is a functional Interface, that contains only one abstract method. Since a functional interface contains only one abstract method we can omit the name of the method present inside of the interface.

For this, instead of using anonymous class we can use lambda Expressions as shown mp.print(str,(s) -> StringParser.convert(str));the whole code is mentioned below.

//Interface
interface parser {
String parse(String str);
}
class StringParser {
public static String convert(String str) {
if (str.length() <= 3) {
str = str.toUpperCase();
} else {
str = str.toLowerCase();
}
return str;
}
}
class MyPrinter {
public void print(String str, parser p) {
str = p.parse(str);
System.out.println(str);
}
}
public class anonymousClassSearch {
public static void main(String[] args) {
String str = "Aman Gupta";
MyPrinter mp = new MyPrinter();
// using Lambda Expressions
mp.print(str, (s) - > StringParser.convert(str));
}
}

Using Standard Functional Interfaces with Lambda Expressions

As we know, Java introduced functional interfaces in its 1.8 version as an interface with only one abstract method. So there exist multiple functional interfaces like Consumer<T> , Predicate<T> etcwhich are some standard functional interfaces.

Consider the following interface, the interface Predicate<T> is an example of a generic interface, we can use this interface when we have a condition which results in boolean value.

interface Predicate<T> {
boolean test(T t);
}

Similarly, we have another functional interface, the interface Consumer<T> an example of generic, we can use this interface when we have no result to display.

Interface Consumer < T > {
void accept(T t);
}

Implementation of above mentioned interfaces is shown below,

package LambdaExpression;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
public class LambdaWithStandardFunctionalInterface {
public static void main(String[] args) {
List < Person > list = Arrays.asList(new Person("ABC", "DEF", 10), new Person("DEF", "GHI", 20), new Person("GHI", "JKL", 30), new Person("JKL", "MNO", 40));
//Prints all the elements whose firstname start with G
printconditionally(list, p - > p.getFirstname().startsWith("G"), p - > System.out.println(p));
}
private static void printconditionally(List < Person > list, Predicate < Person > predicate, Consumer < Person > consumer) {
//Predicate and Consumer are Interfaces present in Java 8
for (Person p: list) {
if (predicate.test(p)) consumer.accept(p); //will print the elements
}
System.out.println(); //new line
}
}

In the above code example, Person is a POJO(Plain Old Java Object) class and its implementation is also given below for reference,

package LambdaExpression;
public class Person {
//Member Variables
private String firstname;
private String lastname;
private int age;
public Person(String firstname, String lastname, int age) {
super();
this.firstname = firstname;
this.lastname = lastname;
this.age = age;
}
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [firstname=" + firstname + ", lastname=" + lastname + ", age=" + age + "]";
}
}

Note

*anonymous class enables us to make our code more concise. It allows us to declare and instantiate class simultaneously.

What di we learn?

After reading this article, users have a thorough knowledge of what lambda expressions are and their usage with existing Java versions. While trying to work with lambdaexpressions or any other feature of Java 8 remember to use JDK 1.8 or higher else these concepts and code will not work.

Summary

As discussed above we have learned:

What is Lambda Expression?
Why Lambda Expression?
Ideal UseCases for Lambda Expression.
Standard Functional Interfaces and more..

6 Comments

Join the conversation! Your thoughts help the community grow.

Priya Gupta6y ago
Superb.....
- Aman Gupta6y ago
  Thanks, Priya
ankurr joshi6y ago
Nice content
- Aman Gupta6y ago
  Thanks for appreciation
Pranshu Singhal6y ago
Good Content. Thanks
- Aman Gupta6y ago
  Thanks for appreciation