Lambda Expression For anyone that needs Java Lambda notes

Lambda Expression
Dr.M.S.Bhuvaneswari, SCORE,VIT

Lambda Expression
• It is an anonymous (that is, unnamed) method
• A lambda expression results in a form of anonymous class.
• This method is not executed on its own. Instead, it is used to implement a
method defined by a functional interface.
• Lambda expressions are also commonly referred to as closures

Lambda Expression Fundamentals
• The lambda expression introduces a new syntax element and operator into the
Java language
• lambda operator or the arrow operator
• Lambda operator divides the lambda expression into two parts.
• The left side specifies any parameters required by the lambda expression.
• On the right side is the lambda body, which specifies the actions of the lambda
expression
• Syntax:
(param1,param2) -> body

• lambda expression consist of three components:
▪ Argument-list: It can be empty or non-empty as well.
▪ Arrow-token: It is used to link arguments-list and body of expression.
▪ Body: It contains expressions and statements for lambda expression.

Lambda Expression
• No Parameter Syntax
() -> {
//Body of no parameter lambda
}
• One Parameter Syntax
(param1) -> {
}

Lambda Expression
Multiple parameter Syntax
(param1, param2) -> {
}

Functional Interface
• A functional interface is an interface that contains one and only one abstract method.
Example: Runnable is a functional interface because it defines only one method
run( )
• It typically represents a single action.
• A functional interface defines the target type of a lambda expression.
• When a lambda expression occurs in a target type context, an instance of a class is
automatically created that implements the functional interface, with the lambda
expression defining the behavior of the abstract method declared by the functional
interface
• A functional interface is sometimes referred to as a SAM type, where SAM stands for
Single Abstract Method.

• Java defines two types of lambda bodies.
▪ single expression
▪ block of code
Normal Method
=============
int findSum()
{
return 20;
}
Lambda Expression
================
() -> 20

Lambda Expression
• In order for a lambda expression to be used in a target type context, the type of
the abstract method and the type of the lambda expression must be compatible
• Rules
▪ The type and number of the lambda expression’s parameters must be
compatible with the method’s parameters;
▪ The return types must be compatible; and
▪ Any exceptions thrown by the lambda expression must be acceptable to the
method

Lambda Expression Example1
interface FuncIntf {
public int getValue();
}
class ClsIntf implements FuncIntf
{
public int getValue()
{
return 20;
}
}
class MyClass
{
public static void main(String[] args)
{
FuncIntf intfRef = new ClsInft();
System.out.println("Value is:"+intfRef.getValue());
}
}

int getValue();
}
class MyClass
{
{
FuncIntf intfRef = new ClsInft();
}
}

int getValue();
}
class MyClass
{
{
FuncIntf intfRef = ;
}
}

int getValue();
}
class MyClass
{
{
FuncIntf intfRef = () -> 20;
}
}
Lambda Expression () -> 20
================
• Implements the method getValue() in FuncIntf
• Returns an instance of the class

Lambda Expression with parameters - Example2
interface FuncIntf
{
int findSum(int a,int b);
}
class MyClass
{
{
FuncIntf intfRef = (x,y)-> {int c=x+y;return c;};
System.out.println("Value is:"+intfRef.findSum(6,8));
}
}

Lambda Expression with parameters type- Example3
interface FuncIntf
{
}
class MyClass
{
{
FuncIntf intfRef = (int x, int y)-> {int c=x+y;return c;};
}
}

Lambda Expression with parameters type- Example4
interface FuncIntf
{
}
class MyClass
{
{
FuncIntf intfRef = (int x, int y)-> {int c=x+y;return c;}; //with return(with multiple statements)
FuncIntf intfRef1 = (int x,int y)-> (x+y); //without return(with only one statement)
System.out.println("Value is:"+intfRef1.findSum(6,8));
}
}

Thread Implementation without Lambda
class MyThread implements Runnable{
public void run()
{
try {
for(int i = 5; i > 0; i--) {
System.out.println("Child Thread: " + i);
Thread.sleep(500);
}
}
catch (InterruptedException e) {
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
}
}

Thread Implementation without Lambda
Runnable rintf=new MyThread()
Thread th1=new Thread(rintf)
th1.start()

Thread Implementation using Lambda
Thread th1=new Thread(() -> {
try {
for(int i = 5; i > 0; i--) {
System.out.println("Child Thread: " + i);
Thread.sleep(500);
}
}
catch (InterruptedException e) {
System.out.println("Child interrupted.");
}
System.out.println("Exiting child thread.");
});
th1.start();

References
• https://www.javatpoint.com/java-lambda-expressions

Lambda Expression For anyone that needs Java Lambda notes

More Related Content

Similar to Lambda Expression For anyone that needs Java Lambda notes (20)

Recently uploaded (20)

Lambda Expression For anyone that needs Java Lambda notes