Table of Contents

1. Introduction
2. Lambda Expressions
3. Functional Interfaces
4. Lambda Expression Syntax
5. Using Lambda Expressions
6. Method References
7. Summary

Introduction

Java Lambda Expressions, introduced in Java 8, are a powerful feature that allows you to write concise and functional code. They provide a cleaner way to represent anonymous functions, making your code more expressive and readable.

Lambda Expressions

A lambda expression is a short block of code that can be passed around as if it were a variable. It's a compact way to represent anonymous functions. Let's break down its structure:

(parameters) -> { body }

• Parameters: The input arguments to the lambda expression.
• Arrow Operator: The `->` symbol separates the parameters from the expression's body.
• Body: The code block that defines the action to be performed.

Functional Interfaces

Functional interfaces are essential for working with lambda expressions. They define a single abstract method that a lambda expression can implement. Java provides several pre-defined functional interfaces in the `java.util.function` package (e.g., `Function`, `Predicate`, `Consumer`), but you can also create your own.

Lambda Expression Syntax

Here's a breakdown of how lambda expressions work:

• No return type: The return type of the lambda expression is inferred based on the functional interface's abstract method.
• Single-line body: If the body contains only one expression, the curly braces can be omitted, and the return value is implicitly returned.
• Multiple-line body: If the body contains multiple statements, curly braces are required, and you explicitly use the `return` keyword.
• Parameter types: The types of the parameters can be explicitly declared or inferred from the context.

Using Lambda Expressions

Let's see some examples:

// Example 1: Using a lambda expression with a Predicate interface
Predicate<Integer> isEven = (number) -> number % 2 == 0;
System.out.println(isEven.test(4)); // Output: true

// Example 2: Using a lambda expression with a Function interface
Function<Integer, String> intToString = (number) -> Integer.toString(number);
System.out.println(intToString.apply(10)); // Output: 10

// Example 3: Using a lambda expression with a Consumer interface
Consumer<String> printMessage = (message) -> System.out.println(message);
printMessage.accept("Hello, Lambda Expressions!");

Method References

Method references are a shorthand way to represent lambda expressions. They provide a concise syntax for referring to existing methods.

// Example 1: Using a method reference to the static method Integer.parseInt()
Function<String, Integer> stringToInt = Integer::parseInt;
System.out.println(stringToInt.apply("123")); // Output: 123

// Example 2: Using a method reference to the instance method String.length()
Function<String, Integer> stringLength = String::length;
System.out.println(stringLength.apply("Hello")); // Output: 5

Summary

• Java Lambda Expressions are concise and expressive anonymous functions that streamline code.
• Functional Interfaces provide a framework for using lambda expressions.
• Lambda expressions can be used for various purposes, such as filtering, mapping, and performing actions.
• Method References offer a shorthand syntax for referring to existing methods.