Lambda Expression Assignment

Ques 1.What is the lambda expression of java 8 ?

Ans - In Java 8, lambda expressions were introduced as a way to
represent a concise syntax for defining anonymous functions. Lambda
expressions enable you to treat functionality as a method argument or
pass code blocks around as if they were data.

The syntax of a lambda expression consists of three main parts:

1. Parameters: They are similar to method parameters but without

specifying the parameter types explicitly (type inference is used).
If there's only one parameter, you can omit the parentheses. For
multiple parameters, parentheses are required.
2. Arrow token (->): This separates the parameter list from the
body of the lambda expression.
3. Body: It specifies the code block or expression to be executed. If
the body contains multiple statements, they should be enclosed in
curly braces {}.

Ques 2.Can you pass lambda expression to a

method? When ?
Ans -
Yes, you can pass lambda expressions as arguments to methods in Java.
This is one of the key features introduced in Java 8, allowing for more
flexible and concise code.

Lambda expressions can be passed as arguments to methods when:

 1. The method parameter accepts a functional interface: If a
method parameter is of a functional interface type, you can pass a
lambda expression that matches the signature of the functional
interface's abstract method. Since lambda expressions are
essentially implementations of functional interfaces, they can be
used interchangeably.
2. The lambda expression's signature matches the method
parameter's functional interface: The lambda expression must
have the same parameter list and return type (if any) as the single
abstract method of the functional interface.
interface MathOperation {
int operate(int a, int b);
}
public class Calculator {
public static int operate(int x, int y, MathOperation operation) {
return operation.operate(x, y);
}
public static void main(String[] args) {
// Passing lambda expression as an argument
int resultAddition = operate(10, 5, (a, b) -> a + b);
int resultSubtraction = operate(10, 5, (a, b) -> a - b);

System.out.println("Addition Result: " + resultAddition);

System.out.println("Subtraction Result: " + resultSubtraction);
}
}
Ques 3.What is the functional interface in java 8?
Ans - In Java 8, a functional interface is an interface that contains
exactly one abstract method. These interfaces are also known as Single
Abstract Method (SAM) interfaces. Functional interfaces provide a way
to represent a contract for a single function or behavior.

Functional interfaces are a key concept in Java 8 because they enable

the use of lambda expressions, method references, and constructor
references, which provide a more concise and expressive way to write
code, especially when dealing with operations that can be represented
as function objects.

Java 8 introduced the @FunctionalInterface annotation to explicitly

designate an interface as a functional interface. While it's not
mandatory to use this annotation, it serves as a helpful reminder for
both developers and compilers.

@FunctionalInterface
interface MyFunctionalInterface {
void doSomething();
}

In this example, MyFunctionalInterface is a functional interface

because it declares exactly one abstract method doSomething(). This
interface can be implemented using lambda expressions or anonymous
inner classes.

Functional interfaces can also contain default methods or static

methods, as long as there's only one abstract method. However, adding
additional abstract methods to a functional interface would invalidate
its status as a functional interface and result in a compilation error.

Here's an example of a functional interface with a default method:

@FunctionalInterface
interface Calculator {
 int calculate(int x, int y);

default void displayResult(int result) {

System.out.println("Result: " + result);
}
}

Ques 4.Why do we use lambda expression in java ?

Ans -
Lambda expressions in Java are used primarily to enable functional
programming paradigms and to provide a more concise and expressive
way of writing code. Here are several reasons why lambda expressions
are used in Java:

1. Conciseness: Lambda expressions allow you to write more

concise code by reducing boilerplate syntax. They enable you to
express functionality in a shorter and more readable form,
especially when used in combination with functional interfaces.
2. Readability: Lambda expressions can improve code readability by
emphasizing the behavior being performed rather than the
mechanics of how it's done. This makes code easier to
understand, maintain, and reason about.
3. Flexibility: Lambda expressions provide a flexible way to
represent behavior as data. They can be passed as arguments to
methods, stored in data structures, or returned from methods,
enabling higher-order functions.
4. Functional Programming: Lambda expressions facilitate
functional programming constructs such as map, filter, reduce,
and forEach. They enable developers to write code in a more
functional style, which can lead to more modular, reusable, and
composable code.
5. Concise Event Handling: Lambda expressions are commonly
used for event handling in graphical user interfaces (GUIs) and
asynchronous programming. They allow you to define event
 handlers inline without the need for verbose anonymous inner
classes.
6. Stream API: Lambda expressions are extensively used with the
Stream API introduced in Java 8. Streams enable functional-style
operations on collections, such as filtering, mapping, and reducing
elements. Lambda expressions make it easy to specify these
operations succinctly.
7. Parallelism and Concurrency: Lambda expressions facilitate
parallelism and concurrency by providing a more functional
approach to writing code that can be easily parallelized. They
enable the use of functional constructs such as parallel streams
and CompletableFuture for asynchronous programming.

Overall, lambda expressions enhance the expressiveness, readability,

and flexibility of Java code, enabling developers to write more concise,
modular, and maintainable applications. They are a fundamental feature
of modern Java programming and are widely used in various domains,
including web development, data processing, and enterprise software
development.

Ques 5.Is it mandatory for a lambda expression to

hava parameters ?
Ans -
No, it's not mandatory for a lambda expression to have parameters.
Lambda expressions can have zero or more parameters depending on
the context in which they are used.

Here are a few examples:

1.Lambda Expression with Zero Parameters:

Runnable runnable = () -> {

System.out.println("Lambda with zero parameters");
};

2.Lambda Expression with One Parameter:

Consumer<String> consumer = (str) -> {
 System.out.println("Lambda with one parameter: " + str);
};

3.Lambda Expression with Multiple Parameters

BiFunction<Integer, Integer, Integer> add = (a, b) -> {

return a + b;

};
4.Lambda Expression without Body (using method reference):
Supplier<Double> random = Math::random;

In these examples:

• The first example demonstrates a lambda expression with zero

parameters, used to implement the Runnable interface.
• The second example shows a lambda expression with one
parameter, used to implement the Consumer functional interface.
• The third example illustrates a lambda expression with multiple
parameters, used to implement the BiFunction functional
interface.
• The fourth example doesn't have explicit parameters but uses a
method reference to Math.random(), which represents a function
that takes no arguments and returns a Double.

Lambda expressions offer flexibility in defining anonymous functions,

allowing you to specify the necessary parameters based on the context
in which they are used.