Lambda expressions in Java provide a concise way of representing functional interfaces. Functional interfaces are those interfaces that define a single abstract method. Lambdas allow us to write inline implementations of these functional interfaces without the need for creating separate classes or objects.
In most cases, lambda expressions are used to perform actions or operations, but sometimes we may need to return a value from a lambda expression. In this blog post, we will discuss how to return values from lambda expressions in Java.
Defining a Functional Interface
Before we dive into returning values from lambda expressions, let’s first define a functional interface. A functional interface is an interface with a single abstract method. For example, let’s define a functional interface called Calculator with a single method calculate:
@FunctionalInterface
interface Calculator {
int calculate(int a, int b);
}
Returning a Value from a Lambda Expression
To return a value from a lambda expression, we need to make sure we use the correct functional interface that has a return type matching our desired value. In the above example, our calculate method returns an int.
Calculator add = (a, b) -> a + b;
System.out.println(add.calculate(5, 3)); // Output: 8
In the above code, we create a lambda expression that adds two numbers. The lambda expression takes two parameters a and b and returns their sum, which is of type int. We assign this lambda expression to an instance of the Calculator interface called add. Then, we invoke the calculate method on add passing 5 and 3 as arguments and print the result, which is 8.
Using Parentheses for Multiple Statements
If we have multiple statements in our lambda expression, we need to enclose them in curly braces and use the return keyword explicitly to return the value.
Calculator multiply = (a, b) -> {
int result = a * b;
return result;
};
System.out.println(multiply.calculate(4, 6)); // Output: 24
In the above code, we create a lambda expression that multiplies two numbers. Inside the curly braces, we define a variable result to hold the result of the multiplication. We explicitly return the result using the return keyword from the lambda expression.
Conclusion
Lambda expressions in Java provide a concise way of defining functional interfaces and writing inline implementations. By using the correct functional interface, we can return values from lambda expressions effortlessly. This allows us to write clean and readable code while still leveraging the power of functional programming.
Returning values from lambda expressions is just one of the many features of Java’s functional programming capabilities. By understanding and utilizing lambda expressions effectively, we can write more expressive and efficient code.
References:
#Java #LambdaExpressions