What is Lamda in java?

Posted on: January 18, 2025 Posted by: rahulgite Comments: 0

Lambda expressions were introduced in Java 8 as a core part of its functional programming features. They enable developers to write more concise, readable, and functional-style code by simplifying how we define and pass behavior.

What is a Lambda Expression?

A lambda expression is an anonymous function (a function without a name) that has:

  • Parameters: Input values for the function.
  • Arrow Token (->): Separates parameters and body.
  • Body: Contains the logic of the function.

Syntax:

(parameters) -> { body }

Examples:

  • (a, b) -> a + b — Adds two numbers.
  • n -> n * n — Squares a number.
  • () -> System.out.println("Hello") — Prints a message.

Components of a Lambda Expression

  1. No Parameters Runnable r = () -> System.out.println("No parameters in lambda"); r.run();
  2. Single Parameter (Parentheses are optional for one parameter) Consumer<String> printer = message -> System.out.println(message); printer.accept("Single parameter example");
  3. Multiple Parameters BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b; System.out.println(add.apply(5, 10));
  4. Single Statement in Body (Curly braces optional) Predicate<Integer> isEven = n -> n % 2 == 0; System.out.println(isEven.test(4));
  5. Multiple Statements in Body (Curly braces and return required) Function<Integer, Integer> square = n -> { int result = n * n; return result; }; System.out.println(square.apply(6));

Functional Interfaces

Lambda expressions work only with functional interfaces (interfaces with a single abstract method). Some commonly used functional interfaces include:

  1. Consumer<T>: Accepts a single argument and returns no result.
    • Consumer<String> consumer = message -> System.out.println(message); consumer.accept("Hello, Consumer!");
  2. Supplier<T>: Provides a result without input.
    • Supplier<Double> randomValue = Math::random; System.out.println(randomValue.get());
  3. Function<T, R>: Accepts one argument and produces a result.
    • Function<Integer, String> intToString = num -> "Number: " + num; System.out.println(intToString.apply(42));
  4. Predicate<T>: Tests a condition and returns true or false.
    • Predicate<Integer> isPositive = n -> n > 0; System.out.println(isPositive.test(5));
  5. BiFunction<T, U, R>: Accepts two arguments and produces a result.
    • BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b; System.out.println(multiply.apply(4, 5));

Using Lambda Expressions

1. Event Handling

Lambda expressions simplify event handling in GUI applications:

button.addActionListener(e -> System.out.println("Button clicked!"));

2. Stream API

The Stream API relies heavily on lambdas for data processing.

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
     .filter(name -> name.startsWith("A"))
     .forEach(System.out::println);

3. Sorting

Simplify sorting logic with lambdas:

List<Integer> numbers = Arrays.asList(5, 2, 8, 1);
numbers.sort((a, b) -> a - b);
System.out.println(numbers);

Method References

Lambdas can refer to methods using method references. This is a shorthand for lambda expressions when the body is a single method call.

  1. Static Method Reference Function<String, Integer> parseInt = Integer::parseInt; System.out.println(parseInt.apply("123"));
  2. Instance Method Reference Consumer<String> printer = System.out::println; printer.accept("Instance Method Reference Example!");
  3. Constructor Reference Supplier<List<String>> listCreator = ArrayList::new; List<String> list = listCreator.get(); System.out.println(list.isEmpty());

Capturing Variables in Lambdas

Lambdas can capture local variables, but these variables must be effectively final.

int multiplier = 2; // Must not change
Function<Integer, Integer> multiply = n -> n * multiplier;
System.out.println(multiply.apply(5));

Advantages of Lambda Expressions

  1. Conciseness: Reduces boilerplate code.
  2. Improved Readability: Simplifies how functions are expressed.
  3. Functional Programming: Enables modern programming styles.
  4. Parallelism: Enhances performance with parallel streams.

Limitations of Lambda Expressions

  1. Debugging: Errors in lambdas can be harder to trace.
  2. Complexity: Unsuitable for complex logic.
  3. Verbose Types: Sometimes type inference may not work as expected, requiring verbose type declarations.

Conclusion

Lambda expressions are a powerful addition to Java, enabling functional programming and concise code. They integrate seamlessly with functional interfaces, the Stream API, and parallel processing. Mastering them is essential for modern Java development.

Leave a Comment