Lambda Syntax

Header Image

Ahoy mateys! If ye be lookin’ to learn about lambdas in Java, ye be in the right place. Today we’re going to be diving into the syntax of lambdas and how they work.

Lambda Expression Syntax

A lambda expression is a way to define an anonymous function that can be passed around as a variable. The syntax for a lambda expression is quite simple:

(parameters) -> expression

Let’s break that down a bit. The parameters are the inputs to the function, separated by commas. These can be any valid Java parameters, such as int, String, or even other objects.

The -> is the lambda operator. It separates the parameters from the body of the function.

The body of the function can be either a single expression or a block of statements enclosed in curly braces. If it’s a single expression, you don’t need to use the return keyword. If it’s a block of statements, you’ll need to use return explicitly.

Here’s an example of a lambda expression that takes two integers as input and returns their sum:

(int a, int b) -> a + b

Lambdas with Parameters and Body

Now that we’ve covered the basic syntax of a lambda expression, let’s take a look at how we can use lambdas with parameters and body.

Lambda Parameters

As mentioned earlier, lambda parameters are defined within parentheses and separated by commas. Let’s take a look at an example of a lambda expression that takes in a String and an int:

(String name, int age) -> System.out.println("Hello, " + name + "! You are " + age + " years old.");

In this example, name and age are the two parameters that are being passed into the lambda expression.

Lambda Body

The lambda body is defined after the arrow operator ->. It can either be a single expression or a block of statements enclosed in curly braces.

Here’s an example of a lambda expression with a single expression as the body:

(int x) -> x * x

In this example, the lambda expression takes in an integer x and returns the square of x.

Here’s an example of a lambda expression with a block of statements as the body:

(int x) -> {
    if (x % 2 == 0) {
        System.out.println(x + " is even");
    } else {
        System.out.println(x + " is odd");
    }
}

In this example, the lambda expression takes in an integer x and prints out whether it is even or odd.

Conclusion

That’s it for the syntax of lambda expressions, me hearties! We’ve covered how to define parameters and the body of a lambda expression. Stay tuned for our next article on functional interfaces in lambda syntax, where we’ll dive into how to use lambdas with functional interfaces. Until then, happy coding!

Lambda Parameters

As mentioned earlier, lambda parameters are defined within parentheses and separated by commas. Let’s take a look at an example of a lambda expression that takes in a String and an int:

(String name, int age) -> System.out.println("Hello, " + name + "! You are " + age + " years old.");

In this example, name and age are the two parameters that are being passed into the lambda expression.

Lambda parameters can also be of different types, including primitive types, objects, or even other lambda expressions.

Here’s an example of a lambda expression that takes in a Person object and returns their full name:

(Person p) -> p.getFirstName() + " " + p.getLastName()

In this example, p is an object of type Person. The lambda expression calls the getFirstName() and getLastName() methods on the Person object to retrieve their first and last names and returns them as a single String.

In some cases, you may have a lambda expression that doesn’t take in any parameters. In this case, you still need to include empty parentheses () to indicate that the lambda expression doesn’t take any parameters.

Here’s an example of a lambda expression with no parameters:

() -> System.out.println("Hello, world!");

In this example, the lambda expression doesn’t take any parameters and simply prints out “Hello, world!” to the console.

That’s it for lambda parameters, me hearties! Stay tuned for the next section where we’ll cover the body of a lambda expression.

Lambda Body

The lambda body is defined after the arrow operator ->. It can either be a single expression or a block of statements enclosed in curly braces.

Single Expression Lambda Body

A single expression lambda body is used when the lambda expression can be represented by a single expression. In this case, the return keyword is optional, and the expression is evaluated and returned automatically.

Here’s an example of a lambda expression with a single expression lambda body:

(int x) -> x * x

In this example, the lambda expression takes in an integer x and returns the square of x.

Block Lambda Body

A block lambda body is used when the lambda expression requires multiple statements or more complex logic. In this case, the lambda body is enclosed in curly braces {} and you need to use the return keyword to return a value explicitly.

Here’s an example of a lambda expression with a block lambda body:

(int x) -> {
    if (x % 2 == 0) {
        return "even";
    } else {
        return "odd";
    }
}

In this example, the lambda expression takes in an integer x and returns the string “even” if x is even, and “odd” if x is odd.

Void Lambda Body

In some cases, a lambda expression may not return a value at all. In this case, you can use a void lambda body, which is simply a block lambda body without a return statement.

Here’s an example of a lambda expression with a void lambda body:

() -> {
    System.out.println("Hello, world!");
}

In this example, the lambda expression doesn’t take any parameters and simply prints out “Hello, world!” to the console.

That’s it for the lambda body, me hearties! Stay tuned for the next section where we’ll cover functional interfaces in lambda syntax.

Functional Interfaces in Lambda Syntax

Lambda expressions are typically used with functional interfaces, which are interfaces that contain exactly one abstract method. The lambda expression can then be used to provide an implementation of that method.

Predefined Functional Interfaces in Java

Java comes with a number of predefined functional interfaces that you can use with lambda expressions. Here are some examples:

Consumer<T>: Accepts a single input argument of type T and performs an operation on it, returning no result.
Function<T, R>: Accepts a single input argument of type T and returns a result of type R.
Predicate<T>: Accepts a single input argument of type T and returns a boolean result.
Supplier<T>: Takes no input arguments and returns a result of type T.

Here’s an example of using the Predicate<T> interface with a lambda expression:

List<String> names = Arrays.asList("Jack", "Jill", "John", "Jane");
List<String> filteredNames = names.stream()
                                   .filter((String name) -> name.startsWith("J"))
                                   .collect(Collectors.toList());

In this example, we’re using a lambda expression with the filter() method of the Stream interface, which takes a Predicate<T> argument. The lambda expression checks whether each name in the list starts with the letter “J”, and returns a boolean result.

Writing Custom Functional Interfaces

You can also create your own custom functional interfaces to use with lambda expressions. To do this, you simply need to define an interface with a single abstract method.

Here’s an example of a custom functional interface:

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

In this example, we’ve defined a functional interface called Calculator, which has a single abstract method called calculate(). We’ve also added the @FunctionalInterface annotation to ensure that this interface is a valid functional interface.

We can then use this interface with a lambda expression like this:

Calculator add = (int x, int y) -> x + y;
Calculator subtract = (int x, int y) -> x - y;

In this example, we’ve created two lambda expressions that implement the Calculator interface. The first lambda expression adds two integers, while the second lambda expression subtracts one integer from another.

Conclusion

Well, me hearties, that’s it for this article on lambda syntax in Java. We’ve covered the basic syntax of lambda expressions, including the parameters and body of a lambda expression, and how to use lambda expressions with functional interfaces. We hope this has been helpful to ye, and happy coding!