A lambda expression in Java 8 is a concise way to represent an anonymous function (a function without a name) that can be passed around as a parameter or executed. It enables functional programming capabilities, allowing you to write cleaner and more readable code, especially when working with collections or streams.

Syntax

(parameters) -> expression
  • Parameters: A list of parameters (similar to method parameters).
  • Arrow (->): Separates the parameters and the body.
  • Expression/Block: The code that gets executed.

Example

// Lambda expression for addition
(int a, int b) -> a + b

How to use lambda expressions in Java 8

  1. With Functional Interfaces:
    • Lambda expressions are commonly used with functional interfaces (interfaces with a single abstract method). Java 8 provides many built-in functional interfaces like Runnable, Callable, Comparator, Predicate, etc.
  2. Using forEach with Collections:
    • You can use lambda expressions to iterate over collections more succinctly.
    List<String> list = Arrays.asList("Java", "Python", "C++");
list.forEach(item -> System.out.println(item));
  3. Using Streams:
    • Lambda expressions work well with Java 8’s Stream API for functional-style operations like filtering, mapping, and reducing.
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
       .filter(n -> n % 2 == 0)
       .forEach(n -> System.out.println(n)); // Output: 2, 4

Benefits of Lambda Expressions

  • Concise Code: Reduces boilerplate code (e.g., eliminates the need for anonymous classes).
  • Readable: Makes the code more readable and expresses the logic more clearly.
  • Functional Programming: Enables a functional programming style, which works well with Java 8’s Stream API.

In summary, lambda expressions in Java 8 provide a clear and concise way to represent functions, improving code readability and allowing functional programming techniques to be applied easily.