Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

forum

home / developersection / forums / what are lambda expressions in java, and how are they used?
Ask Question
Revati S Misra
Revati S Misra

Student

Skilled in SEO, content writing, and digital marketing. Completed several years of working in many organizations including multinational companies. I love to learn new things in life that keep me motivated.

Message

1 Answers

Ashutosh Patel
Ashutosh Patel 19 Jul 2024
Report Abuse

Lambda Expressions in Java

Lambda expressions in Java are a shorthand way of representing anonymous functions: functions without a name that can be executed later by passing them around. They are essentially a way of defining a method without formally declaring it in a class.

The syntax for a lambda expression

The simple lambda expressions contain a single parameter and expression,

parameter -> expression

If you need to use more than one parameter, wrap them into a parentheses (). 

(parameter1, parameter2) -> expression

Here is a simple example where a lambda expression is used to define a function that calculates the square of a number,

Function without lambda expression

public class Main {
   public static void main(String[] args) {
       
       System.out.println(myFuntion(5, 4));
   }
   public static int myFuntion(int a, int b) {       
       return a * b;
   };
}

Function with lambda expression

import java.util.ArrayList;
class Program {
   public static void main(String args[])
   {
       // Creating an ArrayList with elements {1, 2, 3, 4, 5, 6, 7}
       ArrayList<Integer> arrList = new ArrayList<Integer>();
       arrList.add(1);
       arrList.add(2);
       arrList.add(3);
       arrList.add(4);
       arrList.add(5);
       arrList.add(6);
       arrList.add(7);
       // Using lambda expression to print all elements
       System.out.println("All elements");
       arrList.forEach(n -> System.out.print(n+ "\t"));
       // Using lambda expression to print even elements
       System.out.println("\nList of Even Numbers");
       arrList.forEach(n -> {
           if (n % 2 == 0)
               System.out.print(n+ "\t");
       });
       
       // Using lambda expression to print odd elements
       System.out.println("\nList of Odd Numbers");
       arrList.forEach(n -> {
            if(n%2 != 0)
                System.out.print(n+ "\t"); 
       });
   }
}

Output-

All elements
1	2	3	4	5	6	7	
List of Even Numbers
2	4	6	
List of Odd Numbers
1	3	5	7

Usage

Lambda expressions are mainly used in functional networks, which are exactly one-way abstract interfaces. They provide a concise way to implement a method defined by a user interface.

For example, in Java, the java.util.function package contains many function interfaces such as Predicate, Consumer, and Function, which can be effectively implemented in lambda expressions.

Benefits

Conciseness- Lambda expressions reduce the amount of boilerplate code that comes with anonymous classes.
Readability- The code is made readable by focusing on what needs to be done rather than how.
Functional Programming- Lambda expressions enable a highly efficient functional form in Java, facilitating tasks such as mapping, filtering, and reducing collections.


Limitations

There are some restrictions on lambda expressions:

Can only be used in functional interfaces.
Cannot have return statements without curly braces {} around the body.
Cannot contain void as a return type (use Consumer for the void method).
 

When to Use

Lambda expressions are especially useful in situations where you need to pass a statement (to some extent) as an argument to a method or do it asynchronously. It is widely used in streams, threads, event handling, and other functional programming constructs.

Also, Read: What are lambda expressions, and how are they used in LINQ queries?

advertising