Lambda expressions provide a clear and concise way to represent instances of single-method interfaces (functional interfaces) using expressions.

1. Basic Lambda Syntax

Basic Syntax Structure

import java.util.*; public class LambdaBasicSyntax { // Functional interfaces for demonstration @FunctionalInterface interface SimpleFunction { void execute(); } @FunctionalInterface interface StringProcessor { String process(String input); } @FunctionalInterface interface MathOperation { int operate(int a, int b); } @FunctionalInterface interface Validator { boolean isValid(String value); } public static void main(String[] args) { System.out.println("=== Basic Lambda Syntax ==="); // 1. No parameters, no return value SimpleFunction greet = () -> System.out.println("Hello, World!"); greet.execute(); // 2. Single parameter, no type declaration StringProcessor toUpper = s -> s.toUpperCase(); System.out.println("Uppercase: " + toUpper.process("hello")); // 3. Single parameter with parentheses (optional for single parameter) StringProcessor toLower = (s) -> s.toLowerCase(); System.out.println("Lowercase: " + toLower.process("HELLO")); // 4. Multiple parameters MathOperation addition = (a, b) -> a + b; System.out.println("5 + 3 = " + addition.operate(5, 3)); // 5. Multiple parameters with explicit types MathOperation subtraction = (int a, int b) -> a - b; System.out.println("5 - 3 = " + subtraction.operate(5, 3)); // 6. With return statement and curly braces MathOperation multiplication = (a, b) -> { int result = a * b; return result; }; System.out.println("5 * 3 = " + multiplication.operate(5, 3)); // 7. Single expression without return statement MathOperation division = (a, b) -> a / b; System.out.println("6 / 3 = " + division.operate(6, 3)); demonstrateMethodReferences(); } public static void demonstrateMethodReferences() { System.out.println("\n=== Method References vs Lambdas ==="); List<String> names = Arrays.asList("John", "Alice", "Bob", "Carol"); // Lambda expression names.forEach(name -> System.out.println(name)); // Method reference (equivalent) names.forEach(System.out::println); // Lambda for string transformation List<String> upperNames = new ArrayList<>(); names.forEach(name -> upperNames.add(name.toUpperCase())); // Method reference equivalent List<String> lowerNames = new ArrayList<>(); names.forEach(lowerNames::add); // Instance method reference System.out.println("Uppercase: " + upperNames); System.out.println("Lowercase: " + lowerNames); } }

Lambda vs Anonymous Class

import java.util.*; public class LambdaVsAnonymous { @FunctionalInterface interface Calculator { int calculate(int x, int y); } @FunctionalInterface interface Greeter { String greet(String name); } @FunctionalInterface interface Condition { boolean test(int number); } public static void main(String[] args) { System.out.println("=== Lambda vs Anonymous Class ==="); // Anonymous class implementation Calculator anonymousAdd = new Calculator() { @Override public int calculate(int x, int y) { return x + y; } }; // Lambda equivalent Calculator lambdaAdd = (x, y) -> x + y; System.out.println("Anonymous: 5 + 3 = " + anonymousAdd.calculate(5, 3)); System.out.println("Lambda: 5 + 3 = " + lambdaAdd.calculate(5, 3)); // More complex example Greeter anonymousGreet = new Greeter() { @Override public String greet(String name) { return "Hello, " + name + "!"; } }; Greeter lambdaGreet = name -> "Hello, " + name + "!"; System.out.println("Anonymous: " + anonymousGreet.greet("John")); System.out.println("Lambda: " + lambdaGreet.greet("John")); // With multiple statements Condition anonymousCondition = new Condition() { @Override public boolean test(int number) { boolean isEven = number % 2 == 0; boolean isPositive = number > 0; return isEven && isPositive; } }; Condition lambdaCondition = number -> { boolean isEven = number % 2 == 0; boolean isPositive = number > 0; return isEven && isPositive; }; System.out.println("Anonymous test(4): " + anonymousCondition.test(4)); System.out.println("Lambda test(4): " + lambdaCondition.test(4)); demonstrateRunnableExample(); } public static void demonstrateRunnableExample() { System.out.println("\n=== Runnable Example ==="); // Anonymous class Runnable anonymousRunnable = new Runnable() { @Override public void run() { System.out.println("Running from anonymous class"); System.out.println("Thread: " + Thread.currentThread().getName()); } }; // Lambda equivalent Runnable lambdaRunnable = () -> { System.out.println("Running from lambda"); System.out.println("Thread: " + Thread.currentThread().getName()); }; // Execute both new Thread(anonymousRunnable).start(); new Thread(lambdaRunnable).start(); // Even shorter lambda new Thread(() -> System.out.println("Ultra short lambda")).start(); } }

2. Lambda Parameters and Return Types

Various Parameter Scenarios

import java.util.*; import java.util.function.*; public class LambdaParameters { public static void main(String[] args) { System.out.println("=== Lambda Parameters and Return Types ==="); // 1. No parameters Supplier<String> messageSupplier = () -> "Hello from supplier!"; System.out.println(messageSupplier.get()); Runnable noParamRunnable = () -> System.out.println("No parameters"); noParamRunnable.run(); // 2. Single parameter - type inference Function<String, Integer> stringLength = s -> s.length(); System.out.println("Length of 'Hello': " + stringLength.apply("Hello")); Consumer<String> printer = s -> System.out.println("Value: " + s); printer.accept("Test"); // 3. Single parameter with explicit type Function<String, String> explicitType = (String s) -> s.toUpperCase(); System.out.println("Explicit type: " + explicitType.apply("hello")); // 4. Multiple parameters BiFunction<Integer, Integer, Integer> adder = (a, b) -> a + b; System.out.println("5 + 3 = " + adder.apply(5, 3)); // 5. Multiple parameters with explicit types BiFunction<String, String, String> concatenator = (String s1, String s2) -> s1 + " " + s2; System.out.println("Concatenated: " + concatenator.apply("Hello", "World")); // 6. No parameters with block body Supplier<Double> randomSupplier = () -> { Random random = new Random(); return random.nextDouble(); }; System.out.println("Random number: " + randomSupplier.get()); // 7. Complex multi-parameter lambda TriFunction<Integer, Integer, Integer, Integer> complexOperation = (a, b, c) -> { int sum = a + b + c; int product = a * b * c; return sum + product; }; System.out.println("Complex operation: " + complexOperation.apply(1, 2, 3)); demonstrateReturnTypes(); } // Custom functional interface for three parameters @FunctionalInterface interface TriFunction<T, U, V, R> { R apply(T t, U u, V v); } public static void demonstrateReturnTypes() { System.out.println("\n=== Return Type Examples ==="); // Implicit return (single expression) Function<Integer, Integer> square = x -> x * x; System.out.println("Square of 5: " + square.apply(5)); // Explicit return with block Function<Integer, String> numberInfo = x -> { if (x % 2 == 0) { return x + " is even"; } else { return x + " is odd"; } }; System.out.println(numberInfo.apply(4)); System.out.println(numberInfo.apply(7)); // Returning collections Function<Integer, List<Integer>> numberList = count -> { List<Integer> list = new ArrayList<>(); for (int i = 1; i <= count; i++) { list.add(i); } return list; }; System.out.println("Number list: " + numberList.apply(5)); // Void return type Consumer<List<String>> listProcessor = list -> { for (String item : list) { System.out.println("Processing: " + item.toUpperCase()); } }; listProcessor.accept(Arrays.asList("apple", "banana", "cherry")); } }

3. Built-in Functional Interfaces with Lambdas

java.util.function Package Examples

import java.util.*; import java.util.function.*; import java.util.stream.Collectors; public class BuiltInFunctionalInterfaces { public static void main(String[] args) { System.out.println("=== Built-in Functional Interfaces ==="); List<String> names = Arrays.asList("John", "Alice", "Bob", "Carol", "David", "Eve"); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // 1. Predicate - boolean valued function System.out.println("\n=== Predicate Examples ==="); Predicate<String> startsWithA = s -> s.startsWith("A"); Predicate<String> lengthGreaterThan3 = s -> s.length() > 3; List<String> filteredNames = names.stream() .filter(startsWithA.or(lengthGreaterThan3)) .collect(Collectors.toList()); System.out.println("Filtered names: " + filteredNames); // Predicate composition Predicate<Integer> isEven = n -> n % 2 == 0; Predicate<Integer> isGreaterThan5 = n -> n > 5; List<Integer> evenAndGreaterThan5 = numbers.stream() .filter(isEven.and(isGreaterThan5)) .collect(Collectors.toList()); System.out.println("Even and > 5: " + evenAndGreaterThan5); // 2. Function - transforms input to output System.out.println("\n=== Function Examples ==="); Function<String, Integer> stringLength = String::length; Function<String, String> toUpperCase = String::toUpperCase; Function<String, String> addPrefix = s -> "Mr. " + s; List<Integer> nameLengths = names.stream() .map(stringLength) .collect(Collectors.toList()); System.out.println("Name lengths: " + nameLengths); // Function chaining Function<String, String> nameTransformer = toUpperCase.andThen(addPrefix); List<String> transformedNames = names.stream() .map(nameTransformer) .collect(Collectors.toList()); System.out.println("Transformed names: " + transformedNames); // 3. Consumer - accepts input, returns void System.out.println("\n=== Consumer Examples ==="); Consumer<String> simplePrinter = System.out::println; Consumer<String> detailedPrinter = s -> System.out.println("Name: " + s + ", Length: " + s.length()); System.out.println("Simple printing:"); names.forEach(simplePrinter); System.out.println("\nDetailed printing:"); names.forEach(detailedPrinter); // Consumer chaining Consumer<String> chainedConsumer = simplePrinter.andThen(detailedPrinter); System.out.println("\nChained consumer:"); chainedConsumer.accept("Test"); // 4. Supplier - provides results System.out.println("\n=== Supplier Examples ==="); Supplier<Double> randomSupplier = Math::random; Supplier<List<String>> listSupplier = ArrayList::new; Supplier<String> constantSupplier = () -> "Constant Value"; System.out.println("Random: " + randomSupplier.get()); System.out.println("Constant: " + constantSupplier.get()); System.out.println("New list: " + listSupplier.get()); // 5. UnaryOperator and BinaryOperator System.out.println("\n=== Operator Examples ==="); UnaryOperator<String> stringDoubler = s -> s + s; BinaryOperator<Integer> multiplier = (a, b) -> a * b; System.out.println("Double 'Hi': " + stringDoubler.apply("Hi")); System.out.println("5 * 3 = " + multiplier.apply(5, 3)); demonstrateMoreFunctionalInterfaces(); } public static void demonstrateMoreFunctionalInterfaces() { System.out.println("\n=== More Functional Interfaces ==="); List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // BiFunction - two inputs, one output BiFunction<Integer, Integer, String> sumFormatter = (a, b) -> String.format("%d + %d = %d", a, b, a + b); System.out.println("Sum format: " + sumFormatter.apply(5, 3)); // BiConsumer - two inputs, no output BiConsumer<String, Integer> nameAgePrinter = (name, age) -> System.out.println(name + " is " + age + " years old"); nameAgePrinter.accept("John", 25); // BiPredicate - two inputs, boolean output BiPredicate<String, String> sameLength = (s1, s2) -> s1.length() == s2.length(); System.out.println("Same length? " + sameLength.test("hello", "world")); // Specialized functional interfaces IntFunction<String> intToString = i -> "Number: " + i; ToIntFunction<String> stringToLength = String::length; IntUnaryOperator square = x -> x * x; System.out.println(intToString.apply(42)); System.out.println("Length of 'Hello': " + stringToLength.applyAsInt("Hello")); System.out.println("Square of 9: " + square.applyAsInt(9)); } }

4. Lambda Expressions with Collections

Using Lambdas with Java Collections

import java.util.*; import java.util.stream.Collectors; public class LambdaWithCollections { static class Person { String name; int age; String city; public Person(String name, int age, String city) { this.name = name; this.age = age; this.city = city; } public String getName() { return name; } public int getAge() { return age; } public String getCity() { return city; } @Override public String toString() { return String.format("Person{name='%s', age=%d, city='%s'}", name, age, city); } } public static void main(String[] args) { System.out.println("=== Lambda Expressions with Collections ==="); List<Person> people = Arrays.asList( new Person("John", 25, "New York"), new Person("Alice", 30, "Boston"), new Person("Bob", 22, "Chicago"), new Person("Carol", 35, "New York"), new Person("David", 28, "Boston"), new Person("Eve", 19, "Chicago") ); // 1. Sorting with Comparator lambda System.out.println("\n=== Sorting ==="); // Sort by age (ascending) people.sort((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge())); System.out.println("Sorted by age:"); people.forEach(System.out::println); // Sort by name (descending) people.sort((p1, p2) -> p2.getName().compareTo(p1.getName())); System.out.println("\nSorted by name (descending):"); people.forEach(System.out::println); // Using Comparator.comparing with method reference people.sort(Comparator.comparing(Person::getCity).thenComparing(Person::getAge)); System.out.println("\nSorted by city then age:"); people.forEach(System.out::println); // 2. Filtering with Predicate System.out.println("\n=== Filtering ==="); List<Person> adults = people.stream() .filter(p -> p.getAge() >= 25) .collect(Collectors.toList()); System.out.println("Adults (25+): " + adults); List<Person> newYorkers = people.stream() .filter(p -> "New York".equals(p.getCity())) .collect(Collectors.toList()); System.out.println("New York residents: " + newYorkers); // 3. Mapping with Function System.out.println("\n=== Mapping ==="); List<String> names = people.stream() .map(Person::getName) .collect(Collectors.toList()); System.out.println("Names: " + names); List<String> nameAgeCombinations = people.stream() .map(p -> p.getName() + " (" + p.getAge() + ")") .collect(Collectors.toList()); System.out.println("Name with age: " + nameAgeCombinations); // 4. Grouping with Collectors System.out.println("\n=== Grouping ==="); Map<String, List<Person>> peopleByCity = people.stream() .collect(Collectors.groupingBy(Person::getCity)); System.out.println("People by city:"); peopleByCity.forEach((city, cityPeople) -> { System.out.println(city + ": " + cityPeople); }); Map<String, Long> countByCity = people.stream() .collect(Collectors.groupingBy(Person::getCity, Collectors.counting())); System.out.println("Count by city: " + countByCity); demonstrateMapOperations(); } public static void demonstrateMapOperations() { System.out.println("\n=== Map Operations with Lambdas ==="); Map<String, Integer> wordCounts = new HashMap<>(); wordCounts.put("apple", 3); wordCounts.put("banana", 5); wordCounts.put("cherry", 2); // forEach with BiConsumer System.out.println("Word counts:"); wordCounts.forEach((word, count) -> System.out.println(word + ": " + count)); // computeIfAbsent wordCounts.computeIfAbsent("date", k -> 1); wordCounts.computeIfAbsent("apple", k -> 10); // Won't compute, already exists System.out.println("After computeIfAbsent: " + wordCounts); // computeIfPresent wordCounts.computeIfPresent("banana", (word, count) -> count + 10); wordCounts.computeIfPresent("grape", (word, count) -> count + 1); // Won't compute, doesn't exist System.out.println("After computeIfPresent: " + wordCounts); // merge wordCounts.merge("apple", 5, (oldValue, newValue) -> oldValue + newValue); wordCounts.merge("fig", 1, (oldValue, newValue) -> oldValue + newValue); System.out.println("After merge: " + wordCounts); // replaceAll wordCounts.replaceAll((word, count) -> count * 2); System.out.println("After replaceAll (doubled): " + wordCounts); } }

5. Variable Capture in Lambdas

Effectively Final and Variable Capture

import java.util.*; import java.util.function.*; public class LambdaVariableCapture { private String instanceVariable = "Instance Variable"; private static String staticVariable = "Static Variable"; public static void main(String[] args) { System.out.println("=== Variable Capture in Lambdas ==="); LambdaVariableCapture example = new LambdaVariableCapture(); example.demonstrateLocalVariableCapture(); example.demonstrateInstanceAndStaticCapture(); example.demonstrateEffectivelyFinal(); } public void demonstrateLocalVariableCapture() { System.out.println("\n=== Local Variable Capture ==="); // Effectively final local variable final String finalLocal = "Final Local"; String effectivelyFinal = "Effectively Final"; // Lambda capturing local variables Supplier<String> localCapture = () -> { // Can read both final and effectively final variables return finalLocal + " and " + effectivelyFinal; }; System.out.println("Local capture: " + localCapture.get()); // Trying to modify captured variable (will cause compile error) // effectivelyFinal = "Modified"; // Uncommenting this will break the lambda // Array capture (array reference is effectively final, but contents can be modified) int[] counter = {0}; IntSupplier counterLambda = () -> ++counter[0]; // Modifying array content is allowed System.out.println("Counter: " + counterLambda.getAsInt()); System.out.println("Counter: " + counterLambda.getAsInt()); System.out.println("Counter: " + counterLambda.getAsInt()); } public void demonstrateInstanceAndStaticCapture() { System.out.println("\n=== Instance and Static Variable Capture ==="); // Lambda capturing instance variable Supplier<String> instanceCapture = () -> this.instanceVariable; System.out.println("Instance capture: " + instanceCapture.get()); // Lambda capturing static variable Supplier<String> staticCapture = () -> staticVariable; System.out.println("Static capture: " + staticCapture.get()); // Modifying instance variables from lambda Runnable instanceModifier = () -> { this.instanceVariable = "Modified from lambda"; staticVariable = "Static modified from lambda"; }; instanceModifier.run(); System.out.println("After modification:"); System.out.println("Instance: " + instanceCapture.get()); System.out.println("Static: " + staticCapture.get()); } public void demonstrateEffectivelyFinal() { System.out.println("\n=== Effectively Final Concept ==="); List<String> names = Arrays.asList("John", "Alice", "Bob"); // This works - list reference is effectively final names.forEach(name -> System.out.println(name)); // This would cause compile error - modifying effectively final variable // String prefix = "Mr. "; // names.forEach(name -> { // prefix = "Dr. "; // Compile error - cannot assign to effectively final variable // System.out.println(prefix + name); // }); // Workaround using array or wrapper String[] prefixArray = {"Mr. "}; names.forEach(name -> { System.out.println(prefixArray[0] + name); // Can modify array content, but not the array reference prefixArray[0] = "Dr. "; // This is allowed! }); // Using AtomicReference as wrapper java.util.concurrent.atomic.AtomicReference<String> prefixRef = new java.util.concurrent.atomic.AtomicReference<>("Hello "); names.forEach(name -> { String currentPrefix = prefixRef.get(); System.out.println(currentPrefix + name); prefixRef.set("Hi "); // This is allowed! }); } public void demonstrateThisInLambda() { System.out.println("\n=== 'this' in Lambda ==="); // In lambda, 'this' refers to the enclosing instance Runnable lambdaWithThis = () -> { System.out.println("Lambda this: " + this); System.out.println("Lambda this class: " + this.getClass().getSimpleName()); }; lambdaWithThis.run(); // Compare with anonymous class Runnable anonymousWithThis = new Runnable() { @Override public void run() { System.out.println("Anonymous this: " + this); System.out.println("Anonymous this class: " + this.getClass().getSimpleName()); } }; anonymousWithThis.run(); } }

6. Real-World Lambda Examples

Practical Lambda Usage Scenarios

import java.util.*; import java.util.concurrent.*; import java.util.function.*; import java.util.stream.*; public class RealWorldLambdaExamples { static class Product { String name; double price; String category; int stock; public Product(String name, double price, String category, int stock) { this.name = name; this.price = price; this.category = category; this.stock = stock; } public String getName() { return name; } public double getPrice() { return price; } public String getCategory() { return category; } public int getStock() { return stock; } @Override public String toString() { return String.format("Product{name='%-12s', price=$%-6.2f, category='%-10s', stock=%d}", name, price, category, stock); } } public static void main(String[] args) throws Exception { System.out.println("=== Real-World Lambda Examples ==="); List<Product> products = Arrays.asList( new Product("Laptop", 999.99, "Electronics", 10), new Product("Smartphone", 699.99, "Electronics", 25), new Product("Headphones", 149.99, "Electronics", 50), new Product("T-Shirt", 19.99, "Clothing", 100), new Product("Jeans", 49.99, "Clothing", 75), new Product("Book", 12.99, "Education", 200), new Product("Desk Lamp", 29.99, "Home", 30) ); // 1. E-commerce product filtering and transformation demonstrateECommerceOperations(products); // 2. Data processing pipeline demonstrateDataProcessing(products); // 3. Asynchronous operations with CompletableFuture demonstrateAsyncOperations(); // 4. Event handling and callbacks demonstrateEventHandling(); } public static void demonstrateECommerceOperations(List<Product> products) { System.out.println("\n=== E-Commerce Operations ==="); // Filter electronics products List<Product> electronics = products.stream() .filter(p -> "Electronics".equals(p.getCategory())) .collect(Collectors.toList()); System.out.println("Electronics products:"); electronics.forEach(System.out::println); // Apply discount to clothing products Function<Product, Product> applyClothingDiscount = p -> { if ("Clothing".equals(p.getCategory())) { return new Product(p.getName(), p.getPrice() * 0.8, p.getCategory(), p.getStock()); } return p; }; List<Product> discountedProducts = products.stream() .map(applyClothingDiscount) .collect(Collectors.toList()); System.out.println("\nProducts with clothing discount:"); discountedProducts.forEach(System.out::println); // Group products by category Map<String, List<Product>> productsByCategory = products.stream() .collect(Collectors.groupingBy(Product::getCategory)); System.out.println("\nProducts by category:"); productsByCategory.forEach((category, productList) -> { System.out.println(category + ": " + productList.size() + " products"); }); // Calculate total inventory value double totalValue = products.stream() .mapToDouble(p -> p.getPrice() * p.getStock()) .sum(); System.out.printf("\nTotal inventory value: $%.2f%n", totalValue); } public static void demonstrateDataProcessing(List<Product> products) { System.out.println("\n=== Data Processing Pipeline ==="); // Complex data processing pipeline Map<String, Double> categoryAveragePrice = products.stream() .collect(Collectors.groupingBy( Product::getCategory, Collectors.averagingDouble(Product::getPrice) )); System.out.println("Average price by category:"); categoryAveragePrice.forEach((category, avgPrice) -> System.out.printf("%-12s: $%.2f%n", category, avgPrice)); // Products that need restocking (stock < 20) Predicate<Product> needsRestocking = p -> p.getStock() < 20; List<String> productsToRestock = products.stream() .filter(needsRestocking) .map(Product::getName) .collect(Collectors.toList()); System.out.println("\nProducts needing restock: " + productsToRestock); // Price range analysis DoubleSummaryStatistics priceStats = products.stream() .mapToDouble(Product::getPrice) .summaryStatistics(); System.out.println("\nPrice statistics:"); System.out.printf("Count: %d, Min: $%.2f, Max: $%.2f, Average: $%.2f%n", priceStats.getCount(), priceStats.getMin(), priceStats.getMax(), priceStats.getAverage()); } public static void demonstrateAsyncOperations() throws Exception { System.out.println("\n=== Asynchronous Operations ==="); // Simulate async tasks with CompletableFuture CompletableFuture<String> asyncTask1 = CompletableFuture.supplyAsync(() -> { try { Thread.sleep(1000); return "Result from async task 1"; } catch (InterruptedException e) { throw new RuntimeException(e); } }); CompletableFuture<String> asyncTask2 = CompletableFuture.supplyAsync(() -> { try { Thread.sleep(500); return "Result from async task 2"; } catch (InterruptedException e) { throw new RuntimeException(e); } }); // Combine results when both complete CompletableFuture<String> combined = asyncTask1.thenCombine(asyncTask2, (result1, result2) -> result1 + " + " + result2); System.out.println("Combined result: " + combined.get()); // Chain async operations CompletableFuture<Integer> chainedOperation = CompletableFuture.supplyAsync(() -> 5) .thenApplyAsync(x -> x * 2) .thenApplyAsync(x -> x + 10) .thenApplyAsync(x -> x * x); System.out.println("Chained operation result: " + chainedOperation.get()); } public static void demonstrateEventHandling() { System.out.println("\n=== Event Handling ==="); // Simple event system class EventManager { private Map<String, List<Consumer<String>>> listeners = new HashMap<>(); public void addListener(String eventType, Consumer<String> listener) { listeners.computeIfAbsent(eventType, k -> new ArrayList<>()).add(listener); } public void fireEvent(String eventType, String data) { List<Consumer<String>> eventListeners = listeners.get(eventType); if (eventListeners != null) { eventListeners.forEach(listener -> listener.accept(data)); } } } EventManager eventManager = new EventManager(); // Register lambda event handlers eventManager.addListener("login", username -> System.out.println("User logged in: " + username)); eventManager.addListener("purchase", product -> System.out.println("Purchase made: " + product)); eventManager.addListener("error", errorMessage -> System.err.println("Error occurred: " + errorMessage)); // Fire events eventManager.fireEvent("login", "john_doe"); eventManager.fireEvent("purchase", "Laptop"); eventManager.fireEvent("error", "Connection timeout"); // Button click simulation (like in GUI programming) class Button { private String text; private Runnable onClick; public Button(String text) { this.text = text; } public void setOnClick(Runnable onClick) { this.onClick = onClick; } public void click() { System.out.println("Button '" + text + "' clicked"); if (onClick != null) { onClick.run(); } } } Button saveButton = new Button("Save"); saveButton.setOnClick(() -> { System.out.println("Saving data..."); System.out.println("Data saved successfully!"); }); Button cancelButton = new Button("Cancel"); cancelButton.setOnClick(() -> System.out.println("Operation cancelled")); // Simulate button clicks saveButton.click(); cancelButton.click(); } }

Summary

Key Lambda Syntax Rules:

1. Basic Syntax: (parameters) -> expression
2. Parameter Rules:

• No parameters: () -> expression
• Single parameter: param -> expression or (param) -> expression
• Multiple parameters: (param1, param2) -> expression

1. Body Rules:

• Single expression: implicit return
• Block body: { statements; return value; }

Important Concepts:

1. Functional Interfaces: Lambdas work with interfaces having exactly one abstract method
2. Type Inference: Compiler can often infer parameter types
3. Variable Capture: Lambdas can capture effectively final variables
4. Method References: Shorthand for common lambda patterns

Common Use Cases:

1. Collection operations: filtering, mapping, sorting
2. Event handling: GUI events, callbacks
3. Asynchronous programming: CompletableFuture, threads
4. Stream processing: data transformation pipelines
5. Functional programming: higher-order functions

Best Practices:

1. Keep lambdas short and focused
2. Use method references when possible
3. Avoid complex logic in lambdas
4. Be mindful of variable capture
5. Use meaningful parameter names

Lambda expressions make Java code more concise, readable, and functional, enabling modern programming paradigms while maintaining type safety.