Lambda expressions are one of the most significant additions to the Java programming language in recent years. They were introduced in Java 8 and are a way to write more concise and expressive code. Lambda expressions allow you to define and pass around blocks of code, known as functional interfaces, making it easier to write code that is both more readable and maintainable.
In this tutorial, I’ll explain what Lambda expressions are, how to use them in Java, their benefits, and some of their limitations. By the end of this tutorial, you’ll have a solid understanding of Lambda expressions and how to incorporate them into your Java code.
What are Lambda Expressions?
Lambda expressions are a way to define and pass around functionality in a concise and expressive way in Java. A lambda expression is a block of code that can be treated as an object and passed around to methods, much like a variable.
A lambda expression consists of three parts:
- A list of parameters (can be empty if no parameters are needed).
- An arrow (->) that separates the parameters from the lambda body.
- The lambda body, which contains the code to be executed when the lambda expression is called.
The syntax for a lambda expression is as follows:
(parameters) -> { lambda body }
Here’s an example of a lambda expression that takes two integer parameters and returns their sum:
(int x, int y) -> { return x + y; }
Lambda expressions are different from anonymous inner classes in Java in that they are more concise and expressive. They also have better performance because they do not require the creation of a separate class for each instance.
In the next section, we’ll explore how to use lambda expressions in Java with functional interfaces.
Lambda Expressions vs. Anonymous Inner Classes: Which Should You Use?
Before we dive into the specifics of how to use lambda expressions in Java, it’s important to understand why you might want to use them in the first place. At a high level, lambda expressions are a way to write shorter, more concise code. But how do they actually achieve this?
To understand the benefits of using a lambda expression, let’s take a look at an example where we don’t use one. Suppose we want to sort a list of strings in alphabetical order. Here’s how we might write this code using an anonymous inner class:
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
});
In this code, we’re creating a new anonymous inner class that implements the Comparator interface. We then pass an instance of this class to the Collections.sort method, which uses our implementation of the compare method to sort the list.
While this code works perfectly fine, it’s a bit verbose. We’re creating a new class just to define a single method, and the syntax for doing so is quite clunky. This is where lambda expressions come in.
Here’s how we could rewrite the same code using a lambda expression:
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
This code does exactly the same thing as the previous code, but it’s much shorter and more concise. Instead of creating a new anonymous inner class, we’re simply defining a new function inline using a lambda expression. The -> symbol separates the function parameters from the function body, and the whole expression is passed as an argument to the Collections.sort method.
In this case, the benefits of using a lambda expression might not be immediately obvious, since the original code is already quite short. But imagine that we needed to write many more lines of code for our compare method. In that case, the lambda expression would make our code much more readable and maintainable.
In general, the key benefit of using lambda expressions is that they allow us to write more concise and readable code. By defining small functions inline, we can avoid the need to create lots of small anonymous inner classes, which can clutter our code and make it harder to read.
How to Use Lambda Expressions in Java
Lambda expressions are a concise way to implement functional interfaces in Java. A functional interface is an interface that has only one abstract method. Lambda expressions provide a way to implement these methods without the need for a separate class implementation.
Here’s how to use lambda expressions in Java:
- Identify the functional interface you want to implement.
- Define the lambda expression to implement the abstract method of the functional interface.
- Use the lambda expression to call the abstract method of the functional interface.
Let’s look at each of these steps in more detail.
Identify the Functional Interface
Before you can use a lambda expression, you need to identify the functional interface you want to implement. In Java, there are many built-in functional interfaces, such as Runnable, Comparator, and Predicate. You can also create your own functional interfaces by annotating an interface with the @FunctionalInterface annotation.
Here’s an example of a functional interface:
@FunctionalInterface
interface MyInterface {
void myMethod(int arg);
}
This interface has a single method myMethod(int arg).
Define the Lambda Expression
Once you have identified the functional interface, you can define the lambda expression to implement the abstract method. The syntax for a lambda expression is as follows:
(parameter1, parameter2, ...) -> {
// implementation of the abstract method
}
The parameters are the inputs to the method, and the implementation of the abstract method is enclosed in curly braces.
Here’s an example of a lambda expression that implements the MyInterface interface:
MyInterface myLambda = (arg) -> {
System.out.println("Argument: " + arg);
};
This lambda expression takes an integer parameter arg and prints it to the console.
Use the Lambda Expression
Finally, you can use the lambda expression to call the abstract method of the functional interface. In our example, we can call the myMethod(int arg) method of the MyInterface interface using the lambda expression we defined earlier:
myLambda.myMethod(42);
This will print “Argument: 42” to the console.
That’s it! You’ve just used a lambda expression to implement a functional interface in Java. For more information on functional interfaces, you can refer to my tutorial on Functional Interfaces in Java.
Examples: Using Lambda Expressions with Java’s Built-in Functional Interfaces
In Java, there are many built-in functional interfaces, such as Runnable and Comparator. You can also create your own functional interfaces.
Once you have identified the functional interface, you can use a Lambda expression to implement the abstract method. Here’s an example of a Lambda expression that implements the Runnable interface:
Runnable r = () -> {
System.out.println("Hello, world!");
};
In this example, the Lambda expression takes no parameters and simply prints “Hello, world!” to the console. Note that the Lambda expression is assigned to a variable of type Runnable, which is the functional interface that it implements.
You can also use Lambda expressions with functional interfaces that take parameters. Here’s an example of a Lambda expression that implements the Comparator interface:
List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, (s1, s2) -> s1.compareTo(s2));
In this example, the Lambda expression takes two String parameters (s1 and s2) and implements the compare method of the Comparator interface. The expression compares the two Strings lexicographically using the compareTo() method.
Understanding Lambda Expression Parameter Types
Lambda expressions in Java can have parameters, which are declared inside the parentheses () that come after the lambda operator ->. The parameters can be of different types and can have different numbers.
Zero Parameters
If your lambda expression does not require any parameters, you can use an empty pair of parentheses () to indicate that. For example:
() -> System.out.println("Hello, world!");
This lambda expression takes no parameters and simply prints “Hello, world!” to the console.
One Parameter
If your lambda expression requires one parameter, you can declare it inside the parentheses (). For example:
message -> System.out.println("The message is: " + message);
This lambda expression takes a single parameter named message of any data type and prints it along with a message to the console.
Alternatively, you can specify the data type of the parameter explicitly like this:
(String message) -> System.out.println("The message is: " + message);
Multiple Parameters
If your lambda expression requires multiple parameters, you can declare them inside the parentheses () separated by commas ,. For example:
(int x, int y) -> {
int sum = x + y;
System.out.println("The sum of " + x + " and " + y + " is " + sum);
}
This lambda expression takes two int parameters named x and y, adds them together, and prints the result to the console.
Parameter Types
The data types of lambda expression parameters can be explicitly or implicitly specified. Here are some examples:
// Explicitly specified data types (String s, int n) -> s.substring(0, n) // Implicitly specified data types (s, n) -> s.substring(0, n) // Mixing explicit and implicit data types (String s, int n) -> s.substring(0, n) (s, n) -> s.substring(0, n)
The first version explicitly specifies the data types of the parameters as “String” and “int”. The second version omits the data types, using only the parameter names, which Java can infer from the context. The third version shows that you can mix and match explicit and implicit data types. Both versions are equivalent, and the Java compiler can deduce the data types for the implicit version based on the context in which it is used.
All three versions implement the same functionality, taking a substring of the input String up to the specified index “n”.
var Parameter Types from Java 11
Starting from Java 11, you can use the var keyword to declare the type of a lambda parameter implicitly. For example:
(var s, var n) -> s.substring(0, n)
In this example, the data types of the parameters are inferred from the context, based on the method signature. Note that using var for lambda expression parameters is optional, and you can still use explicit or implicit data types as shown in the previous examples.
Lambda Expression Body Types
There are three types of Lambda Expression body types in Java:
- Expression Body
- Block Body
- Empty Body
Expression Body
The Expression Body is the most common type of Lambda Expression body. In this case, the Lambda Expression consists of a single expression that returns a value. The syntax for an Expression Body Lambda is as follows:
(parameter(s)) -> expression
Here’s an example of an Expression Body Lambda that takes two integer parameters and returns their sum:
(int a, int b) -> a + b
Block Body
The Block Body is used when you need to perform more than one operation in the body of a Lambda Expression. In this case, the Lambda Expression consists of a block of statements enclosed in curly braces. The syntax for a Block Body Lambda is as follows:
(parameter(s)) -> {
statement(s);
return expression;
}
Here’s an example of a Block Body Lambda that takes an integer parameter and returns a boolean value:
(int num) -> {
if (num % 2 == 0) {
return true;
} else {
return false;
}
}
Empty Body
The Empty Body is used when you don’t need to perform any operations in the body of a Lambda Expression. In this case, the Lambda Expression consists of an empty pair of curly braces. The syntax for an Empty Body Lambda is as follows:
() -> {}
The Empty Body Lambda Expression in Java can be useful when you need to pass a Lambda Expression to a method that expects a functional interface with a void return type.
For example, let’s say you have a method doSomething that takes a Runnable as a parameter. The Runnable interface has a single method run() that takes no arguments and returns void. You can use an Empty Body Lambda Expression to pass as a Runnable to the doSomething method as follows:
doSomething(() -> {} );
In this case, the Empty Body Lambda Expression () -> {} satisfies the signature of the run() method in the Runnable interface, which takes no arguments and returns void. The doSomething method will execute the lambda expression by calling its run() method, but since there are no statements inside the lambda expression, nothing will actually be executed.
Lambda Expressions: To Return or Not to Return?
In Java, lambda expressions can be written with or without an explicit return statement. When the lambda expression has a single statement, the return keyword can be omitted. When there are multiple statements, or if you need to explicitly specify the return type, you must use the return keyword.
Let’s take a look at some examples to illustrate this:
// Lambda expression without return keyword
Function<Integer, Integer> square = (num) -> num * num;
// Lambda expression with return keyword
Function<Integer, Integer> power = (num) -> {
return num * num * num;
};
In the first example, we define a lambda expression that takes an integer and returns its square. Since the expression only has a single statement (num * num), we can omit the return keyword.
In the second example, we define a lambda expression that takes an integer and returns its cube. Since the expression has multiple statements (num * num * num), we need to include the return keyword and enclose the statement within a block.
You can also use the return keyword to explicitly specify the return type of the lambda expression. Here’s an example:
interface MathOperation {
int operation(int a, int b);
}
// Lambda expression with explicit return type
MathOperation add = (int a, int b) -> { return a + b; };
In this example, we define a functional interface called MathOperation, which has a single abstract method called operation that takes two integer parameters and returns an integer result.
We then define a lambda expression called add, which takes two integer parameters a and b, adds them together, and returns the result as an integer value. The return type is explicitly specified as int in the lambda expression. The lambda expression is assigned to a variable of type MathOperation, which is the functional interface that it implements.
By default, when a lambda expression has no return type specified, Java infers the return type based on the context in which the lambda is used. If the lambda is used in a context that requires a return value, Java will assume that the lambda returns a value of that type. For example:
interface MathOperation {
int operate(int a, int b);
}
public class LambdaExample {
public static void main(String[] args) {
// Lambda expression with explicit return type
MathOperation add = (a, b) -> {
return a + b;
};
// Lambda expression with implicit return type
MathOperation multiply = (a, b) -> a * b;
// Test the lambda expressions
int result1 = add.operate(10, 5);
int result2 = multiply.operate(3, 4);
System.out.println("10 + 5 = " + result1);
System.out.println("3 * 4 = " + result2);
}
}
In this example, we define a custom functional interface MathOperation with a single abstract method operate(int a, int b). We then define two lambda expressions to implement this interface – add and multiply. The lambda expression add explicitly specifies the return type using the return keyword, while multiply implicitly infers the return type based on the expression a * b.
We then test the lambda expressions by passing in two operands to the operate method and printing the results. The output should be:
10 + 5 = 15 3 * 4 = 12
Method References as Lambdas
In Java, Method References are a shorthand notation for Lambda Expressions. They allow you to reference a method without executing it. Method references are useful when you want to pass a method as an argument to another method or when you want to use a method as a Lambda expression.
Static Method References
Static method references are used to reference a static method in a class. A static method is a method that is declared with the static keyword and can be called without creating an instance of the class.
You can create a static method reference by using the :: operator followed by the name of the class and the method you want to reference. Consider the following example:
public class MethodReferencesExample {
public static void main(String[] args) {
List<String> list = Arrays.asList("apple", "banana", "orange");
// Using a static method reference to sort the list
Collections.sort(list, MethodReferencesExample::compareByLength);
System.out.println(list);
}
public static int compareByLength(String s1, String s2) {
return Integer.compare(s1.length(), s2.length());
}
}
In this code example, we have a class called MethodReferencesExample which contains a static method compareByLength that compares the length of two strings and returns an integer value. The main method of the class creates a List of strings and assigns it some values.
The code then uses a static method reference to call the compareByLength method to sort the list based on the length of each string in ascending order using the Collections.sort method. Finally, the sorted list is printed to the console.
Parameter Method References
Parameter method references are used to reference a method that takes one or more parameters. You can create a parameter method reference by using the :: operator followed by the name of the class and the method you want to reference. Consider the example below:
public class MethodReferencesExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// Using a parameter method reference to sum the numbers
int sum = numbers.stream()
.reduce(0, MethodReferencesExample::sum);
System.out.println(sum);
}
public static int sum(int a, int b) {
return a + b;
}
}
In this code example, we have a MethodReferencesExample class with a sum method that takes two integer parameters and returns their sum.
In the main method, we create a list of integers and use the reduce method of the Stream API to compute the sum of the integers. The first parameter of the reduce method is the initial value of the sum, which is 0 in this case.
The interesting part is the second parameter of the reduce method, which is a reference to the sum method of the MethodReferencesExample class. This is achieved using the MethodReferencesExample::sum syntax, which is a parameter method reference. The reduce method uses this reference to call the sum method with two parameters, which are the accumulated value of the sum and the next element of the stream.
Finally, the computed sum is printed to the console.
Instance Method References
Instance method references are used to reference an instance method of an object. An instance method is a method that is called on an instance of a class.
You can create an instance method reference by using the :: operator followed by the name of the object and the method you want to reference. For example, take a look at the following piece of code:
public class MethodReferencesExample {
public static void main(String[] args) {
List<String> list = Arrays.asList("apple", "banana", "orange");
// Using an instance method reference to print each element in the list
list.forEach(System.out::println);
}
}
The code creates a class called “MethodReferencesExample” with a main method. Inside the main method, the code creates a list of strings containing the elements “apple”, “banana”, and “orange”.
The method reference System.out::println is then used to print each element in the list. This method reference refers to the println method of the System.out object, which is a static reference to the standard output stream.
The forEach method is called on the list object and the method reference is passed as an argument. This results in each element of the list being printed to the console on a separate line.
Constructor References
Constructor references are used to create objects of a class using its constructors. A constructor is a special method that is used to create an instance of a class.
You can create a constructor reference by using the :: operator followed by the name of the class and the keyword new. Consider the following example:
public class MethodReferencesExample {
public static void main(String[] args) {
List<String> list = Arrays.asList("apple", "banana", "orange");
// Using a constructor reference to create a new ArrayList
List<String> newList = list.stream()
.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
System.out.println(newList);
}
}
In this code example, a new List<String> is created using a constructor reference. First, a List<String> named list is created with the Arrays.asList method, containing the values “apple”, “banana”, and “orange”. The list is then converted into a stream using the stream() method.
The collect method is then called on the stream to collect the stream elements into a new List<String>. The first argument of the collect method is a constructor reference to create a new instance of ArrayList<String> to hold the elements. The second argument is a method reference to the add method of the ArrayList class, which is used to add each element of the stream to the new ArrayList. The third argument is another method reference to the addAll method of the ArrayList class, which is used to add all the elements of the stream to the new ArrayList.
Finally, the resulting List<String> is printed to the console using the println method.
Bonus Example: Lambda Expressions with a Foreach Loop in Java
Lambda expressions provide a concise way to write anonymous functions in Java. One of the most common use cases for lambda expressions is with a foreach loop, which allows you to iterate over a collection of objects and perform some action on each element.
Here’s an example of using a lambda expression with a foreach loop in Java:
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
names.forEach(name -> System.out.println("Hello, " + name + "!"));
In this example, we create a List of Strings and then use the forEach method to iterate over each element in the list. The forEach method takes a lambda expression as an argument, which in this case is used to print out a personalized greeting for each name in the list.
The lambda expression name -> System.out.println("Hello, " + name + "!") takes a single parameter, which represents each element in the list, and then performs an action on that element. In this case, the action is to print out a greeting with the name of the current element.
You can use lambda expressions with a foreach loop to perform any action on each element in a collection, such as filtering out certain elements or performing a calculation on each element.
Here’s an example of using a lambda expression with a foreach loop to calculate the sum of all integers in a List:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
numbers.forEach(num -> sum += num);
System.out.println("The sum of the numbers is: " + sum);
In this example, we create a List of integers and then use the forEach method to iterate over each element in the list. We then use a lambda expression to add each element to a running total, which is stored in the sum variable. Finally, we print out the total sum of all the integers in the list.
Lambda expressions with a foreach loop can be a powerful tool in your Java programming toolbox, allowing you to write concise and readable code for iterating over collections and performing actions on each element.
Benefits of Lambda Expressions
Lambda expressions were introduced in Java 8 to simplify the process of working with functional interfaces, which are interfaces with a single abstract method. Lambda expressions allow developers to write shorter, more concise code while still maintaining the same functionality as traditional Java code.
Here are some benefits of using Lambda expressions in Java:
- Improved code readability: Lambda expressions allow developers to write code in a more concise and readable way. They eliminate the need for boilerplate code and make it easier to understand the intent of the code.
- Increased productivity: With Lambda expressions, developers can write code more quickly and efficiently. This means that they can complete tasks faster and move on to other projects more quickly.
- Simplified multithreading: In traditional Java code, multithreading can be complex and error-prone. Lambda expressions simplify the process by providing a more streamlined way to write code for concurrent programming.
- Enhanced code maintainability: By using Lambda expressions, developers can reduce the amount of code they need to write and maintain. This means that they can spend less time fixing bugs and more time working on new features.
- Easy integration with existing code: Lambda expressions can be easily integrated with existing Java code. This means that developers can start using Lambda expressions in their code without having to rewrite everything from scratch.
Overall, Lambda expressions provide a significant benefit to Java developers by simplifying the process of writing code and making it more efficient, readable, and maintainable. By using Lambda expressions, developers can focus on writing the best code possible and delivering high-quality software.
Drawbacks of Lambda Expressions
While Lambda expressions offer several benefits, they also have some limitations that you should be aware of. Here are some of the drawbacks of Lambda expressions in Java:
- Limited Support for Mutable State: Lambda expressions should be stateless to work optimally. Mutable state, such as changing a variable value, may lead to unexpected behavior and create race conditions when multiple threads are involved. Thus, you should be careful when using mutable state with Lambda expressions.
- Lack of Type Information: Lambda expressions rely on type inference, which can make it difficult to determine the data type of the parameters and return value. This lack of type information can make debugging more challenging and require additional documentation to clarify the intended types.
- Difficulties in Debugging: Lambda expressions can be challenging to debug since they are typically anonymous and often only appear in the context of a larger codebase. As a result, debugging Lambda expressions can be more difficult than debugging regular code.
- Code Readability Issues: While Lambda expressions can help to reduce boilerplate code, they can also make the code harder to read and understand, especially when multiple Lambda expressions are chained together. Developers may find it more challenging to understand the code’s flow and intent.
- Learning Curve: Finally, Lambda expressions may be challenging to understand and implement for developers who are new to functional programming concepts. While Lambda expressions are a powerful tool, they require a different way of thinking about programming than traditional object-oriented programming techniques.
In summary, while Lambda expressions provide many benefits, they also have some drawbacks to consider. As a developer, you need to carefully evaluate whether the benefits of Lambda expressions outweigh the potential drawbacks in the specific use case.
Conclusion
Lambda expressions in Java are a powerful tool that can help reduce boilerplate code, increase readability, and provide a functional programming paradigm. While they do have some drawbacks, the benefits of Lambda expressions make them a valuable addition to any Java developer’s toolkit. By understanding the syntax and best practices for using Lambda expressions, you can improve the quality and efficiency of your code.
I hope this tutorial has provided you with a solid foundation for understanding Lambda expressions in Java and has given you the confidence to start incorporating them into your own projects. Don’t forget to check out the Java Tutorial for Beginners page for more Java tutorials.
Frequently asked questions
- Can Lambda expressions be used with any interface in Java?
Lambda expressions in Java can only be used with functional interfaces that have only one abstract method. They cannot be used with interfaces that have more than one abstract method. - Are there any performance issues associated with using Lambda expressions?
Lambda expressions in Java have minimal performance issues, with some potential overhead during their creation and invocation, as well as copying variables from the enclosing scope. However, these concerns are typically negligible and do not significantly affect the program’s performance. - Can Lambda expressions be used to replace all uses of anonymous inner classes in Java?
Lambda expressions can replace anonymous inner classes in Java for functional interfaces, which have only one abstract method. This makes the code shorter and easier to read. But for non-functional interfaces, anonymous inner classes are still needed because they can implement multiple methods. - Can Lambda expressions be used in conjunction with streams in Java?
Lambda expressions and streams are commonly used together in Java to perform functional-style operations on collections of data. This approach allows for more concise and expressive manipulation of data, including filtering, mapping, and reducing elements of the stream. This results in efficient and easy-to-understand functional-style code.