Lambda expressions in Java 8 explained with code samples

You Java 8 introduced a new feature called lambda expressions. In this blog post, I will be explaining lambda expressions in detail.

Edit

What are lambda expressions

Lambda expressions are used to define anonymous functions, that is a function without a name.  Lambda expressions and functional interfaces together help in writing clean code. A functional interface is nothing but an interface with a single method. In order to understand more about functional interfaces, you can refer to this blog post. Lambda expressions can be used to implement functional interfaces.

Lambda expression syntax

The general syntax of a lambda expression is as follows:

(parameters) -> {method body}

Parameters

Parameters specify the parameters to be passed to the lambda expression. You can pass one or more parameters. You need to enclose the parameters in parentheses. If there is only one parameter, you can skip the parentheses. Also, parameters are optional. If the lambda expression does not accept any parameters, you need to specify empty parantheses.

 

Lambda Operator

-> specifies the lambda operator.

Lambda expression body

You need to follow the lambda operator with the body of the lambda expression. You can include any code in the body of the lambda expression. Also, you need to include Curly brackets around the body only if the body consists of more than one statement.

Lambda expression example

Lambda expressions are used to implement functional interfaces. Consider the following code snippet:

@FunctionalInterfacepublic interface DemoInterface {public void aMethod();}

You can implement his interface using a Lambda expression as follows:

public class DemoClass {public static void main(String args[]){DemoInterface demoInterface = () -> System.out.println("Demo Interface");demoInterface.aMethod();}}

Here, we are assigning the lambda expression () -> System.out.println(“Demo Interface”); to an instance of the DemoInterface. The lambda expression provides the implementation for the method aMethod in the interface. So when the code invokes this method, the code within the lambda expression is executed.  In this case, it simply has a Sysout statement. So when you execute this code, it will print the following output:

Demo Interface

Advantages of lambda expressions

Keeping Code concise

Lambda expressions help to keep the code concise. Prior to Java 8, we would need to write code similar to the following in order to implement a functional interface:

public class DemoClass implements DemoInterface{public static void main(String args[]){DemoInterface demoInterface = new DemoClass();demoInterface.aMethod();}public void aMethod(){System.out.println("Demo Interface");}}

So basically, we need to create a class that implements the interface, provide an implementation for the method in the interface and invoke this method. When you compare this code to the code written earlier using lambda expressions it is much cleaner. You just need to write one line of code

Passing around code as arguments

Lamda expressions are anonymous functions. They allow you to pass code as method arguments. So consider the following code snippet:

public interface Shape {public void draw();}public class ShapeDemo {public static void main(String[] args) {drawShape(() -> System.out.println("Drawing Rectangle"));drawShape(() -> System.out.println("Drawing Circle"));drawShape(() -> System.out.println("Drawing Triangle"));}public static void drawShape(Shape shape){shape.draw();}}

This code defines a functional interface Shape with a method draw. The ShapeDemo class has a method drawShape that accepts a Shape object. It invokes the draw method. Instead of passing a Shape implementation for each Shape (i.e. Rectangle, Circle and Triangle), the main method passes a lambda expression corresponding to the implementation for each Shape.

When you execute this code, it will print the following output:

Drawing RectangleDrawing CircleDrawing Triangle

Comments

Post a Comment

Popular posts from this blog

How to use logging in SpringBoot with code samples

Image
In this article, we will learn how to use logging in SpringBoot. Introduction There are several Java logging frameworks like logback, log4j, and so on. Spring Boot supports out-of-the-box support for logback. Let us learn how to use logging in SpringBoot with logback. Step 1 – Create a New Maven Project Create a new Maven project. (Refer to  this  blog post). This will create a project in Eclipse as follows:   Step 2 – Add the Spring Boot Dependencies Add the spring-boot-starter-web dependency to the pom.xml . So, the pom.xml should look as follows: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.learnjava</groupId> <artifactId>learnjava-springboot-logging-example</artifactId> <version>0.0.1-SNAPSHOT&
Read more

Python While Loop with code samples

Much like a Java while loop, you can use a Python while loop to repeatedly execute a block of code as long as a condition is true. In this article, we will learn more about the Python while loop. Python While loop Syntax A while loop in Python has the following syntax: while <condition>: loop body The while keyword is followed by a condition. If the condition evaluates to true, the body of the loop is executed. Once the body of the loop is completed, the condition is checked again and this is repeated until the condition evaluates to false at which point the loop is exited. While loop Sample Code The following code demonstrates how you can use the while loop: num=10counter=1total=0while counter<=num: total += counter counter+=1print("sum of first 10 numbers is",total) This code adds the numbers from 1 to 10 and prints the sum. It uses a while loop to iterate from 1 to 10. The while loop checks the condition counter <= num and if so adds the current value of count
Read more

How to convert a List to a Set

In this blog post ,I will be showing you how you can convert a List to a Set. Consider the following code snippet: public class ListToSetDemo {public static void main(String[] args) {List<Integer> list = Arrays.asList(5,3,11,15,9);//Method 1Set<Integer> set = new HashSet<Integer>(list);System.out.println("Set is "+set);//method 2Set<Integer> set2 = new HashSet<Integer>();set2.addAll(list);System.out.println("Set is "+set2);}} This code demonstrates two ways to convert a List to a Set. Method 1 Here, we are creating a new HashSet . We are invoking the constructor that accepts a Collection object. Here, we are passing in the input list to this constructor.   Method 2 Here again, we are creating a new HashSet . However, we are using the default constructor. We are then invoking the addAll method and passing in the input list.   When you run this code, it will print the following output: Set is [3, 5, 9, 11, 15]Set is [3, 5, 9, 11, 15] No
Read more