Lambda Expressions

🔍 What Is It?

Lambda Syntax:

// Full syntax
(Type param1, Type param2) -> { return expression; }

// Short forms
(x) -> x * 2              // single param, expression body
x -> x * 2                // parentheses optional for single param
() -> System.out.println("hello")  // no params
(a, b) -> a + b            // multiple params
(a, b) -> {                // block body with multiple statements
    int sum = a + b;
    return sum;
}

What lambdas can do:

• →Implement any functional interface (interface with one abstract method)
• →Capture effectively final local variables from enclosing scope
• →Be passed as method arguments
• →Be stored in variables of functional interface type
• →Be returned from methods

Method References (shorthand for lambdas):

String::toUpperCase       // instance method reference
Integer::parseInt         // static method reference
System.out::println       // instance method on specific object
Employee::new             // constructor reference

🎯 Why Do We Need It?

Before Java 8, passing behavior required anonymous inner classes:

// Java 7: verbose anonymous class
list.sort(new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
});

// Java 8: lambda
list.sort((a, b) -> a.compareTo(b));

// Even shorter with method reference
list.sort(String::compareTo);

Lambdas enable:

• →Streams API — functional pipeline processing
• →CompletableFuture — async callbacks
• →Event handlers — concise UI/event code
• →Strategy pattern — pass behavior as data
• →Reduced boilerplate — 10 lines becomes 1

🏗️ What Happens in Real Projects?

Lambdas are everywhere in modern Java:

• →Stream operations: filter, map, reduce, collect
• →Comparator.comparing() for sorting
• →Optional.ifPresent(), orElseGet()
• →CompletableFuture callbacks
• →Spring @Bean definitions
• →Event listeners

⚙️ How It Works

Lambdas are functional interface implementations:

Every lambda implements exactly one functional interface. The compiler infers which interface based on context.

Variable Capture:

Lambdas can capture variables from the enclosing scope, but only if they are effectively final (never reassigned after initial assignment).

Under the hood:

Lambdas are NOT anonymous inner classes. The JVM uses invokedynamic bytecode instruction to create lambda instances efficiently. Lambda instances are created lazily and may be cached — they are more memory-efficient than anonymous classes.

this in lambdas:

this refers to the enclosing class instance, NOT the lambda itself (unlike anonymous classes where this refers to the anonymous class instance).

💻 Example

Lambdas in Enterprise Code — The lambda patterns you will use every day in Java development.

// Comparator — sorting
List<Employee> employees = getEmployees();

// Sort by salary descending, then by name ascending
employees.sort(Comparator
    .comparing(Employee::getSalary).reversed()
    .thenComparing(Employee::getName));

// Runnable — execute in thread
Thread t = new Thread(() -> System.out.println("Running in thread"));
t.start();

// Predicate — filtering
Predicate<Employee> isActive = emp -> emp.isActive();
Predicate<Employee> isHighEarner = emp -> emp.getSalary().compareTo(new BigDecimal("100000")) > 0;
Predicate<Employee> activeHighEarner = isActive.and(isHighEarner);
Predicate<Employee> notActive = isActive.negate();

List<Employee> filtered = employees.stream()
    .filter(activeHighEarner)
    .collect(Collectors.toList());

// Function — transformation
Function<String, Integer> strToInt = Integer::parseInt;
Function<Integer, String> intToStr = String::valueOf;
Function<String, String> parseAndDouble = strToInt.andThen(n -> n * 2).andThen(intToStr);

// Consumer — side effects
Consumer<String> logger = msg -> log.info("Processing: {}", msg);
Consumer<String> emailSender = email -> emailService.send(email);
Consumer<String> logAndEmail = logger.andThen(emailSender);

// Supplier — lazy evaluation
Supplier<List<Employee>> lazyEmployees = () -> employeeRepo.findAll();
// Only calls findAll() when .get() is called
List<Employee> emps = lazyEmployees.get();

// BiFunction — two inputs
BiFunction<String, Integer, String> repeat = (s, n) -> s.repeat(n);
String result = repeat.apply("ha", 3);  // "hahaha"

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits