Java Lambda Expressions Explained — Syntax, Use Cases and Pitfalls

import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class FunctionalInterfaceDemo {

    // A custom functional interface — one abstract method, that's the rule
    @FunctionalInterface
    interface DiscountCalculator {
        double apply(double originalPrice, double discountPercent);
    }

    public static void main(String[] args) {

        // --- Built-in functional interfaces ---

        // Predicate: ask a yes/no question about a value
        Predicate<String> isLongEnough = username -> username.length() >= 6;
        System.out.println(isLongEnough.test("ali"));       // false — too short
        System.out.println(isLongEnough.test("alice99"));   // true

        // Function: transform one value into another
        Function<String, String> toGreeting = name -> "Hello, " + name + "!";
        System.out.println(toGreeting.apply("Maria"));      // Hello, Maria!

        // Consumer: receive a value and do something with it (no return)
        Consumer<String> logToConsole = message -> System.out.println("[LOG] " + message);
        logToConsole.accept("User logged in");              // [LOG] User logged in

        // Supplier: produce a value without taking any input
        Supplier<String> defaultUsername = () -> "guest_" + System.currentTimeMillis();
        System.out.println(defaultUsername.get());         // e.g. guest_1718200000000

        // --- Custom functional interface used as a lambda ---
        // The lambda implements the single abstract method 'apply'
        DiscountCalculator blackFridayDeal = (price, percent) -> price - (price * percent / 100);
        double finalPrice = blackFridayDeal.apply(199.99, 20);
        System.out.printf("Final price after discount: $%.2f%n", finalPrice); // $159.99
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class OrderPipelineDemo {

    record Order(String orderId, String customerName, double totalAmount) {}

    public static void main(String[] args) {

        List<Order> recentOrders = Arrays.asList(
            new Order("ORD-001", "Alice",  45.00),
            new Order("ORD-002", "Bob",   210.50),
            new Order("ORD-003", "Carol", 130.75),
            new Order("ORD-004", "David",  89.99),
            new Order("ORD-005", "Eve",   305.00)
        );

        double loyaltyThreshold = 100.00;
        double loyaltyDiscountRate = 0.10; // 10% off for big spenders

        // Stream pipeline — each arrow is a lambda
        List<String> discountedSummaries = recentOrders.stream()

            // Lambda as Predicate<Order>: keep only high-value orders
            .filter(order -> order.totalAmount() > loyaltyThreshold)

            // Lambda as Function<Order, String>: transform each order into a readable summary
            .map(order -> {
                // Multi-line lambda body needs braces and explicit return
                double discounted = order.totalAmount() * (1 - loyaltyDiscountRate);
                return String.format("%s (%s): $%.2f → $%.2f after loyalty discount",
                        order.orderId(), order.customerName(),
                        order.totalAmount(), discounted);
            })

            // Sort alphabetically by customer name — Comparator is also a functional interface
            .sorted((a, b) -> a.compareTo(b))  // or simply: .sorted()

            .collect(Collectors.toList());

        // Lambda as Consumer<String>: print each result
        discountedSummaries.forEach(summary -> System.out.println(summary));

        System.out.println("\nTotal qualifying orders: " + discountedSummaries.size());
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class MethodReferenceDemo {

    static String formatAsTag(String word) {
        // Wraps a word in an HTML-style tag — used to demo static method reference
        return "<b>" + word.toLowerCase() + "</b>";
    }

    public static void main(String[] args) {

        List<String> rawTags = Arrays.asList("Java", "  ", "Lambdas", "", "Streams", "  ");

        // --- Static method reference: ClassName::staticMethod ---
        // Equivalent lambda: word -> MethodReferenceDemo.formatAsTag(word)
        List<String> htmlTags = rawTags.stream()
            .filter(tag -> !tag.isBlank())          // remove blank/whitespace strings
            .map(MethodReferenceDemo::formatAsTag)  // static method reference
            .collect(Collectors.toList());

        System.out.println("HTML tags: " + htmlTags);

        // --- Instance method reference on arbitrary instance: ClassName::instanceMethod ---
        // Equivalent lambda: s -> s.toUpperCase()
        List<String> upperCaseTags = htmlTags.stream()
            .map(String::toUpperCase)   // calls toUpperCase() on each String in the stream
            .collect(Collectors.toList());

        System.out.println("Uppercase: " + upperCaseTags);

        // --- Instance method reference on a specific object ---
        String separator = "---";
        // Equivalent lambda: s -> separator.concat(s)
        List<String> separated = htmlTags.stream()
            .map(separator::concat)
            .collect(Collectors.toList());

        System.out.println("Separated: " + separated);

        // --- Constructor reference: ClassName::new ---
        // Equivalent lambda: s -> new StringBuilder(s)
        List<StringBuilder> builders = List.of("hello", "world").stream()
            .map(StringBuilder::new)
            .collect(Collectors.toList());

        builders.forEach(sb -> System.out.println(sb.reverse()))  ; // reverse each word
    }
}

import java.util.List;
import java.util.ArrayList;
import java.util.function.Predicate;

public class VariableCaptureDemo {

    private int processedCount = 0; // instance variable — lambdas CAN modify this

    public List<String> filterProducts(List<String> productNames, int minLength) {
        // 'minLength' is effectively final — never reassigned, so it CAN be captured
        Predicate<String> meetsLengthRequirement = name -> name.length() >= minLength;

        List<String> results = new ArrayList<>();

        for (String name : productNames) {
            if (meetsLengthRequirement.test(name)) {
                results.add(name);
                processedCount++; // instance variable: safe to modify inside lambda/method
            }
        }
        return results;
    }

    public static void main(String[] args) {
        VariableCaptureDemo demo = new VariableCaptureDemo();

        List<String> products = List.of(
            "Pen", "Notebook", "USB Hub", "Monitor", "Pad", "Keyboard"
        );

        // minLength = 6 — never changed after assignment, so it's effectively final
        int minLength = 6;
        List<String> longNames = demo.filterProducts(products, minLength);

        System.out.println("Products with 6+ characters: " + longNames);
        System.out.println("Items processed: " + demo.processedCount);

        // --- Demonstrating the restriction ---
        // Uncomment the lines below to see the compiler error:
        //
        // int counter = 0;
        // products.forEach(p -> counter++); // ERROR: counter is NOT effectively final
        //
        // FIX: use an instance variable (shown above) or an AtomicInteger for thread safety:
        //
        // java.util.concurrent.atomic.AtomicInteger atomicCounter = new java.util.concurrent.atomic.AtomicInteger(0);
        // products.forEach(p -> atomicCounter.incrementAndGet()); // This works fine
        // System.out.println("Atomic count: " + atomicCounter.get());
    }
}