Renaud Humbert-Labeaumaz
Posted on March 18, 2019
A lambda is an anonymous function that can be assigned to a variable, passed as an argument of a method and invoked at any time. We can find lambdas in Java and C# and the resulting code is very similar. A Java lambda can be viewed as the implementation of an interface with only one method (called a functional interface) whereas a C# lambda can be assigned to a delegate, which is a concept that does not exist in Java. This article aims to explain how lambdas work in Java and C# and highlight their differences and similarities.
Java Functional Interfaces
In Java, a lambda can simply be viewed as an anonymous function that implements an interface with only one method. This kind of interface is called a functional interface and can be annotated with the @FunctionalInterface annotation that tells the compiler to enforce the only-one-method rule:
@FunctionalInterface
interface Printer {
void print(String message);
}
// The function interface is implemented with a lambda
Printer standardPrinter = message -> System.out.println(message);
// The print method of standardPrinter can be invoked
standardPrinter.print("Hello World!");
From the previous snippet, you should note that the way the interface is implemented makes absolutely no difference. It can be a lambda, a concrete class or even an anonymous class. Anyways, you can simply invoke the print method of the interface.
There are some pre-defined generic functional interfaces in the JDK that can be used directly off the shelf. The main ones are described below:
| Name | Method | Role |
|---|---|---|
Function<T,R> |
R apply(T t) |
Takes an argument of a given type T and returns an object of type R |
Consumer<T> |
void accept(T) |
Takes an argument of a given type T and does something useful (typically with side effects) |
Predicate<T> |
boolean test(T) |
Takes an argument of a given type T and returns a boolean (similar to Function<T, Boolean>) |
Supplier<T> |
T get() |
Returns an object of type T |
C# Delegates
In C#, a lambda can be assigned to a delegate which is a type that encapsulates a method:
delegate void Print(string message);
// A lambda is assigned to the delegate
Print print = message => System.Console.WriteLine(message);
// print can be directly invoked as a method
print("Hello World!");
Like in Java, some delegates are already defined in the .NET framework, the main ones are described below:
| Method | Role |
|---|---|
TResult Func<in T,out TResult>(T arg) |
Takes an argument of a given type T and returns an object of type TResult |
void Action<in T>(T obj) |
Takes an argument of a given type T and does something useful (typically with side effects) |
bool Predicate<in T>(T obj) |
Takes an argument of a given type T and returns a boolean (similar to Func<T, bool>) |
Conclusion
From a Java perspective, using lambdas in APIs (like Linq for instance) is pretty straightforward. However, when digging a little bit deeper, there are some subtle differences to understand. I find the Java approach simpler as it does not introduce another concept but the C# approach is cleaner because the delegate can be invoked directly like a method.
Posted on March 18, 2019
Join Our Newsletter. No Spam, Only the good stuff.
Sign up to receive the latest update from our blog.
Related
