In this article, we will discuss some important and frequently asked Java Lambda Expressions Interview Questions and Answers.
Learn Java 8 Lambda expressions with examples at Lambda Expressions guide.
1. What is a Lambda Expression?
A lambda expression is simply a function without any name. It can even be used as a parameter in a function. Lambda Expression facilitates functional programming and simplifies development a lot.
The main use of Lambda expression is to provide an implementation for functional interfaces.
Syntax of Lambda Expression
The syntax of a lambda expression is characterized by the following three parts:
Parameters: A lambda expression can have zero or more parameters, enclosed in parentheses.
Arrow Token: The arrow token -> separates the parameters from the body of the lambda.
Body: The body of the lambda contains expressions or statements describing the method's functionality.
(parameters) -> expression
Or
(parameters) -> { statements; }
Example
Consider a simple functional interface:
@FunctionalInterface
interface MyFunction {
int apply(int x, int y);
}
A lambda expression implementing this interface:
MyFunction add = (x, y) -> x + y;
int result = add.apply(5, 3); // result is 8
Lambda expressions in Java are a powerful feature that provides several key benefits:
Conciseness: Lambda expressions allow you to write instances of anonymous classes more concisely. This makes the code easier to read and maintain.
Functional Programming: Lambda expressions enable functional programming concepts in Java. You can pass functions as method arguments, return them as values, and perform operations like mapping and filtering on collections more naturally.
Readability: By reducing boilerplate code, lambda expressions can make the main logic of a program more apparent. The concise syntax allows for clear expression of the computation or action being performed.
Parallel Execution Support: Lambdas work well with the Stream API, which supports parallel execution. This makes it easier to write parallel code, leveraging multicore processors without having to deal with low-level threading details.
Less Verbose: Unlike anonymous inner classes, lambda expressions are less verbose. You don't need to name the class, declare the method, or even type the input parameters.
Strong Typing: Lambda expressions are strongly typed. The compiler infers the types of parameters, return values, and exceptions, which can lead to more robust code.
Scope Flexibility: Lambda expressions have access to final variables or effectively final variables from the surrounding scope, allowing more natural encapsulation of behavior.
Interoperability: Lambdas can be used wherever functional interfaces are expected, providing great interoperability with existing code, libraries, and frameworks that use functional interfaces.
4. Which of the following are valid lambda expressions?
A.
String a, String b -> System.out.print(a+ b);
B.
() -> return;
C.
(int i) -> i;
D.
(int i) -> i++; return i;
Answer
The correct answer is C.
Explanation
Option C is valid. The body doesn't need to use the return keyword if it only has one statement.
5. Write a Java Lambda Expression to Create a Thread
Creating a thread using a lambda expression in Java is straightforward and concise. You can define the task you want the thread to perform as a lambda and pass it to the Thread constructor.
Here's an example:
Runnable task = () -> {
for (int i = 0; i < 5; i++) {
System.out.println("Running inside the thread: " + i);
}
};
Thread myThread = new Thread(task);
myThread.start();
Or you can simplify it further by passing the lambda expression directly to the Thread constructor:
Thread myThread = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Running inside the thread: " + i);
}
});
myThread.start();
Either way, this code creates a new thread and runs a simple loop inside it, printing a message five times. Lambda expressions make this code cleaner and more concise by removing the need to create an anonymous inner class or implement a separate class that implements Runnable.
6. How are Lambda Expressions and Functional Interfaces related?
The main use of Lambda expression is to provide an implementation for functional interfaces.
A lambda expressions provide a compact and expressive way to create instances of functional interfaces, implementing the interface's single abstract method with the body of the lambda. This relationship promotes a more functional programming style in Java, allowing for more concise and readable code.
For example, Lambda expression provides an implementation for a Printable functional interface:
interfacePrintable {voidprint(Stringmsg);
}
publicclassJLEExampleSingleParameter {
publicstaticvoidmain(String[] args) {
// without lambda expressionPrintable printable =newPrintable() {
@Overridepublicvoidprint(Stringmsg) {
System.out.println(msg);
}
};
printable.print(" Print message to console....");
// with lambda expressionPrintable withLambda = (msg) ->System.out.println(msg);
withLambda.print(" Print message to console....");
}
}
Output :
Print message to console....
Print message to console....
7. Explain the Various Forms of Writing Lambda Expressions.
Lambda expressions in Java can be written in various forms, depending on the signature of the functional interface's abstract method they are implementing. Here are some different ways to write lambda expressions:
No Parameters, No Return Value:
If the abstract method takes no parameters and returns no value, the lambda expression can be written with empty parentheses and a body:
() -> System.out.println("Hello, World!");
Single Parameter, No Type Declaration:
If the abstract method takes a single parameter, you can omit the parentheses around the parameter, and the type can be inferred:
s -> System.out.println(s);
Single Parameter, With Type Declaration:
You can also explicitly declare the type of the parameter:
(String s) -> System.out.println(s);
Multiple Parameters:
If the abstract method takes multiple parameters, you must include parentheses around the parameters. Types can be inferred or explicitly declared:
(a, b) -> a + b;
(int a, int b) -> a + b;
Return Statement:
If the body of the lambda consists of a single expression that returns a value, you can write it directly:
(int a, int b) -> a + b;
If the body consists of multiple statements, you must include braces and use a return statement:
(int a, int b) -> {
int sum = a + b;
return sum;
};
No Parameters, Return Value:
If the abstract method takes no parameters but returns a value, you can write it like this:
() -> 42;
Use Local Variables:
You can also access local variables from the enclosing scope within the lambda expression:
int factor = 2;
(int a) -> a * factor;
8. How is Lambda Expression Different from Anonymous Class?
Lambda expressions provide a more concise way to implement functional interfaces, whereas anonymous classes are more verbose. Lambdas don’t create a separate class file or object.
Here’s a clear comparison:
9. Can Lambdas Access Local Variables?
Yes, lambda expressions can access final or effectively final local variables from the enclosing scope. This means the variable should not be modified after it’s used inside the lambda.
Example:
String prefix = "Hello "; Consumer<String> c = name -> System.out.println(prefix + name); c.accept("Ravi");
If you try to change prefix later, the compiler will throw an error.
10. What is the Difference Between Lambda and Method Reference?
Both lambda expressions and method references are used to provide implementations for functional interfaces. A method reference is a shorter way to write certain lambdas that call existing methods.
Comments
Post a Comment
Leave Comment