Unit 10: Nested Classes & Lambda Expressions

Opening Hook — One Line That Changed Java Forever

Java — Before (Anonymous Class)
interface FeeCalculator {
    double calculate(Order order);
}

FeeCalculator calculator = new FeeCalculator() {
    @Override
    public double calculate(Order order) {
        return order.getDistance() * 2.5;
    }
};

Java — After (Lambda)
Function<Order, Double> feeCalculator = order -> order.getDistance() * 2.5;

Learning Outcomes — Bloom's Taxonomy Mapped

Concept Explanation — Nested Classes & Lambdas from Scratch

1. Static Nested Class

A static nested class is a class defined inside another class with the static keyword. It is logically grouped with the outer class but does not need an instance of the outer class to be created. Think of it as a helper class that belongs to the outer class conceptually but is independent in terms of instance creation.

Java
public class Restaurant {
    private static String platformName = "Swiggy";
    private String restaurantName;

    public Restaurant(String name) {
        this.restaurantName = name;
    }

    // Static nested class — does NOT need a Restaurant instance
    static class MenuItem {
        String itemName;
        double price;

        MenuItem(String itemName, double price) {
            this.itemName = itemName;
            this.price = price;
        }

        void display() {
            // Can access static member of outer class
            System.out.println(platformName + " | " + itemName + " — ₹" + price);
            // Cannot access restaurantName (non-static) — compile error!
        }
    }

    public static void main(String[] args) {
        // Created WITHOUT a Restaurant instance
        Restaurant.MenuItem item = new Restaurant.MenuItem("Chicken Biryani", 299);
        item.display();
    }
}

2. Non-static Inner Class

A non-static inner class (simply called an "inner class") is defined inside another class without the static keyword. It has an implicit reference to an instance of the enclosing class, meaning it can directly access all members — including private instance variables — of the outer class.

Java
public class Order {
    private String customerName;
    private double totalAmount;

    public Order(String customerName, double totalAmount) {
        this.customerName = customerName;
        this.totalAmount = totalAmount;
    }

    // Non-static inner class — has access to outer class fields
    class Invoice {
        private String invoiceId;

        Invoice(String invoiceId) {
            this.invoiceId = invoiceId;
        }

        void print() {
            // Directly accessing outer class's private fields!
            System.out.println("Invoice: " + invoiceId);
            System.out.println("Customer: " + customerName);
            System.out.println("Amount: ₹" + totalAmount);
        }
    }

    public static void main(String[] args) {
        Order order = new Order("Rahul Gupta", 450.0);
        // Inner class needs an outer class instance
        Order.Invoice invoice = order.new Invoice("INV-2024-001");
        invoice.print();
    }
}

3. Local Class (Inside a Method)

A local class is declared inside the body of a method. It exists only within the scope of that method and can access local variables of the method — but only if those variables are effectively final (their value doesn't change after assignment).

Java
public class DeliveryTracker {

    void trackOrder(String orderId) {
        final String status = "In Transit";  // effectively final

        // Local class — exists only inside this method
        class GPSUpdate {
            double latitude, longitude;

            GPSUpdate(double lat, double lng) {
                this.latitude = lat;
                this.longitude = lng;
            }

            void display() {
                // Can access local variable 'status' (effectively final)
                System.out.println("Order " + orderId + " — " + status);
                System.out.println("Location: " + latitude + ", " + longitude);
            }
        }

        GPSUpdate update = new GPSUpdate(12.9716, 77.5946);
        update.display();
    }

    public static void main(String[] args) {
        new DeliveryTracker().trackOrder("SWG-88421");
    }
}

4. Anonymous Class — The Bridge to Lambda

An anonymous class is a class with no name. It is declared and instantiated in a single expression, usually to provide a one-time implementation of an interface or abstract class. Before Java 8, anonymous classes were the primary way to pass behaviour as a parameter.

The Evolution Story: Interface → Anonymous Class → Lambda Expression

Step 1: Define an Interface

Java
interface DeliveryFeeCalculator {
    double calculate(double distance);
}

Step 2: Implement with a Named Class (Traditional)

Java
class StandardFeeCalculator implements DeliveryFeeCalculator {
    @Override
    public double calculate(double distance) {
        return distance * 2.5;
    }
}

// Usage: 3 lines of ceremony for 1 line of logic
DeliveryFeeCalculator calc = new StandardFeeCalculator();
System.out.println(calc.calculate(5.0)); // 12.5

Step 3: Implement with Anonymous Class (Java 1.1+)

Java
DeliveryFeeCalculator calc = new DeliveryFeeCalculator() {
    @Override
    public double calculate(double distance) {
        return distance * 2.5;
    }
};
System.out.println(calc.calculate(5.0)); // 12.5

Step 4: Replace with Lambda Expression (Java 8+) 🎉

Java
DeliveryFeeCalculator calc = distance -> distance * 2.5;
System.out.println(calc.calculate(5.0)); // 12.5

From 7 lines (anonymous class) to 1 line (lambda). The compiler infers the interface type, the method name, the parameter type, and the return type — all from context.

5. Functional Interface — The Foundation of Lambdas

A functional interface is an interface with exactly one abstract method. It can have any number of default methods and static methods, but only one abstract method. The @FunctionalInterface annotation is optional but recommended — it tells the compiler to enforce the single-abstract-method rule.

Java
// Custom functional interface
@FunctionalInterface
interface PriceCalculator {
    double compute(double basePrice, int quantity);

    // default method — does NOT break @FunctionalInterface
    default double withGST(double basePrice, int qty) {
        return compute(basePrice, qty) * 1.18;
    }

    // static method — does NOT break @FunctionalInterface
    static String currency() { return "INR"; }
}

// Usage with lambda
PriceCalculator totalPrice = (price, qty) -> price * qty;
System.out.println(totalPrice.compute(299, 3));      // 897.0
System.out.println(totalPrice.withGST(299, 3));    // 1058.46

Common Built-in Functional Interfaces (Preview)

6. Lambda Expression Syntax — All Forms

A lambda expression is an anonymous function: no name, a parameter list, an arrow (->), and a body. Java infers the types from context (target typing).

Java
Runnable greet = () -> System.out.println("Namaste!");
greet.run();  // Namaste!

Java
// With parentheses
Function<Integer, Integer> square = (x) -> x * x;

// Without parentheses — valid for single parameter
Function<Integer, Integer> cube = x -> x * x * x;

System.out.println(square.apply(5));  // 25
System.out.println(cube.apply(3));    // 27

Java
BiFunction<Double, Double, Double> add = (a, b) -> a + b;
System.out.println(add.apply(10.5, 20.3));  // 30.8

Java
BiFunction<Integer, Integer, String> maxFinder = (a, b) -> {
    if (a > b) {
        return "First is greater: " + a;
    } else {
        return "Second is greater: " + b;
    }
};
System.out.println(maxFinder.apply(42, 17));
// First is greater: 42

7. Lambda in Action — Runnable, Comparator, Custom FI

Lambda with Runnable — Thread Creation

Java
public class LambdaRunnable {
    public static void main(String[] args) {
        // Old way — anonymous class
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread 1 running (anonymous class)");
            }
        });

        // New way — lambda
        Thread t2 = new Thread(() -> System.out.println("Thread 2 running (lambda)"));

        t1.start();
        t2.start();
    }
}

Lambda with Comparator — Sorting Lists

Java
import java.util.*;

public class LambdaComparator {
    public static void main(String[] args) {
        List<String> restaurants = Arrays.asList(
            "Biryani Blues", "Dominos", "Annapurna", "Zaitoon"
        );

        // Sort alphabetically using lambda
        restaurants.sort((a, b) -> a.compareTo(b));
        System.out.println("A-Z: " + restaurants);

        // Sort by string length using lambda
        restaurants.sort((a, b) -> a.length() - b.length());
        System.out.println("By length: " + restaurants);
    }
}

Lambda with Custom Functional Interface

Java
@FunctionalInterface
interface DiscountPolicy {
    double applyDiscount(double price);
}

public class SwiggyDiscount {
    static double finalPrice(double price, DiscountPolicy policy) {
        return policy.applyDiscount(price);
    }

    public static void main(String[] args) {
        DiscountPolicy flat20  = price -> price * 0.80;
        DiscountPolicy flat50  = price -> price - 50;
        DiscountPolicy noDisc  = price -> price;

        System.out.println("20% off ₹500: ₹" + finalPrice(500, flat20));
        System.out.println("₹50 off ₹500: ₹" + finalPrice(500, flat50));
        System.out.println("No discount ₹500: ₹" + finalPrice(500, noDisc));
    }
}

8. Method References — Lambda Shorthand (::)

A method reference is a shorthand notation for a lambda expression that calls an existing method. If a lambda simply calls a method and passes its parameters through, you can replace it with a method reference using the :: operator.

Type 1: Static Method Reference — ClassName::staticMethod

Java
import java.util.function.Function;

public class StaticMethodRef {
    public static void main(String[] args) {
        // Lambda version
        Function<String, Integer> parser1 = s -> Integer.parseInt(s);

        // Method reference version
        Function<String, Integer> parser2 = Integer::parseInt;

        System.out.println(parser1.apply("42"));  // 42
        System.out.println(parser2.apply("99"));  // 99
    }
}

Type 2: Instance Method Reference (Bound) — instance::method

Java
import java.util.*;
import java.util.function.Consumer;

public class InstanceMethodRef {
    public static void main(String[] args) {
        List<String> items = Arrays.asList("Biryani", "Dosa", "Paneer Tikka");

        // Lambda version
        items.forEach(item -> System.out.println(item));

        // Method reference — System.out is the instance
        items.forEach(System.out::println);
    }
}

Type 3: Constructor Reference — ClassName::new

Java
import java.util.function.Supplier;
import java.util.function.Function;
import java.util.ArrayList;

public class ConstructorRef {
    public static void main(String[] args) {
        // No-arg constructor reference
        Supplier<ArrayList<String>> listMaker = ArrayList::new;
        ArrayList<String> list = listMaker.get();
        list.add("Swiggy");
        list.add("Zomato");
        System.out.println(list);

        // One-arg constructor reference
        Function<String, StringBuilder> sbMaker = StringBuilder::new;
        StringBuilder sb = sbMaker.apply("Hello Lambda!");
        System.out.println(sb);
    }
}

Type 4: Arbitrary Instance Method — ClassName::instanceMethod

Java
import java.util.*;

public class ArbitraryInstanceRef {
    public static void main(String[] args) {
        List<String> cities = Arrays.asList("bangalore", "mumbai", "delhi", "pune");

        // Lambda version
        cities.replaceAll(s -> s.toUpperCase());

        // Equivalent method reference — calls toUpperCase on each String
        // cities.replaceAll(String::toUpperCase);

        System.out.println(cities);

        // Sorting with arbitrary instance method ref
        List<String> names = Arrays.asList("Zomato", "Swiggy", "Dunzo");
        names.sort(String::compareToIgnoreCase);
        System.out.println(names);
    }
}

Method Reference Summary Table

9. java.util.function — The Standard Toolkit

Java 8 introduced the java.util.function package with dozens of ready-made functional interfaces. You rarely need to define your own — these cover 95% of use cases.

Predicate<T> — Boolean Test / Filtering

Java
import java.util.function.Predicate;
import java.util.*;
import java.util.stream.Collectors;

public class PredicateDemo {
    public static void main(String[] args) {
        Predicate<Integer> isAdult = age -> age >= 18;
        Predicate<String> isVeg = item -> item.startsWith("Paneer") || item.startsWith("Dal");

        System.out.println("Is 20 adult? " + isAdult.test(20));   // true
        System.out.println("Is 15 adult? " + isAdult.test(15));   // false

        // Chaining predicates with and(), or(), negate()
        Predicate<Integer> isSenior = age -> age >= 60;
        Predicate<Integer> isWorkingAge = isAdult.and(isSenior.negate());
        System.out.println("Is 30 working age? " + isWorkingAge.test(30)); // true
        System.out.println("Is 65 working age? " + isWorkingAge.test(65)); // false

        // Filtering a list
        List<String> menu = Arrays.asList("Paneer Tikka", "Chicken 65", "Dal Makhani", "Fish Fry");
        List<String> vegItems = menu.stream().filter(isVeg).collect(Collectors.toList());
        System.out.println("Veg items: " + vegItems);
    }
}

Function<T, R> — Transformation

Java
import java.util.function.Function;

public class FunctionDemo {
    public static void main(String[] args) {
        Function<String, Integer> strLength = s -> s.length();
        Function<Integer, String> toRupees = amt -> "₹" + amt;

        System.out.println(strLength.apply("Swiggy"));   // 6
        System.out.println(toRupees.apply(299));        // ₹299

        // Chaining with andThen and compose
        Function<Integer, Integer> doubleIt = x -> x * 2;
        Function<Integer, Integer> addTen  = x -> x + 10;

        // andThen: first doubleIt, then addTen → (5 * 2) + 10 = 20
        System.out.println(doubleIt.andThen(addTen).apply(5));

        // compose: first addTen, then doubleIt → (5 + 10) * 2 = 30
        System.out.println(doubleIt.compose(addTen).apply(5));
    }
}

Consumer<T> — Consume & Act

Java
import java.util.function.Consumer;
import java.util.Arrays;
import java.util.List;

public class ConsumerDemo {
    public static void main(String[] args) {
        Consumer<String> printUpper = s -> System.out.println(s.toUpperCase());
        Consumer<String> printLength = s -> System.out.println("Length: " + s.length());

        // Single consumer
        printUpper.accept("biryani");  // BIRYANI

        // Chaining consumers with andThen
        Consumer<String> printBoth = printUpper.andThen(printLength);
        printBoth.accept("paneer tikka");

        // Using with forEach
        List<String> dishes = Arrays.asList("Dosa", "Idli", "Vada");
        dishes.forEach(printUpper);
    }
}

Supplier<T> — Generate / Factory

Java
import java.util.function.Supplier;
import java.util.Random;

public class SupplierDemo {
    public static void main(String[] args) {
        Supplier<String> orderIdGen = () -> "SWG-" + new Random().nextInt(100000);
        Supplier<Double> randomPrice = () -> 99 + new Random().nextDouble() * 400;

        System.out.println("Order 1: " + orderIdGen.get());
        System.out.println("Order 2: " + orderIdGen.get());
        System.out.println("Random price: ₹" + String.format("%.2f", randomPrice.get()));
    }
}

BiFunction<T, U, R> — Two-Argument Transformation

Java
import java.util.function.BiFunction;

public class BiFunctionDemo {
    public static void main(String[] args) {
        BiFunction<Double, Integer, Double> totalPrice =
            (unitPrice, qty) -> unitPrice * qty;

        BiFunction<String, String, String> fullAddress =
            (street, city) -> street + ", " + city + ", India";

        System.out.println("Total: ₹" + totalPrice.apply(249.0, 3));
        System.out.println(fullAddress.apply("MG Road", "Bangalore"));
    }
}

java.util.function — Master Reference Table

Learn by Doing — 3-Tier Lab Structure

Java
class Restaurant {
    String name;
    double rating;
    int deliveryTime; // minutes
    double minOrder;

    Restaurant(String name, double rating, int deliveryTime, double minOrder) {
        this.name = name;
        this.rating = rating;
        this.deliveryTime = deliveryTime;
        this.minOrder = minOrder;
    }

    public String toString() {
        return name + " (⭐" + rating + ", " + deliveryTime + "min, ₹" + minOrder + ")";
    }
}

Java
import java.util.*;

public class ZomatoSorter {
    public static void main(String[] args) {
        List<Restaurant> restaurants = new ArrayList<>(Arrays.asList(
            new Restaurant("Biryani Blues", 4.3, 35, 199),
            new Restaurant("Dominos", 4.1, 25, 99),
            new Restaurant("Paradise", 4.5, 40, 249),
            new Restaurant("Annapurna", 4.0, 20, 149),
            new Restaurant("Meghana Foods", 4.6, 30, 299)
        ));

        // STEP 3: OLD WAY — Sort by rating (anonymous class)
        restaurants.sort(new Comparator<Restaurant>() {
            @Override
            public int compare(Restaurant r1, Restaurant r2) {
                return Double.compare(r2.rating, r1.rating);
            }
        });
        System.out.println("By Rating (old): " + restaurants);

        // STEP 4: NEW WAY — Sort by rating (lambda)
        restaurants.sort((r1, r2) -> Double.compare(r2.rating, r1.rating));
        System.out.println("By Rating (lambda): " + restaurants);

        // STEP 5: Sort by delivery time (lambda)
        restaurants.sort((r1, r2) -> r1.deliveryTime - r2.deliveryTime);
        System.out.println("By Speed: " + restaurants);

        // STEP 6: Sort by name (method reference)
        restaurants.sort(Comparator.comparing(r -> r.name));
        System.out.println("By Name: " + restaurants);
    }
}

Java
// Hint 1: Supplier for order ID
Supplier<String> idGenerator = () -> "SWG-" + /* generate random 5-digit number */;

// Hint 2: Predicate for free delivery eligibility
Predicate<Order> freeDelivery = order -> /* check if totalAmount >= 500 */;

// Hint 3: Function for delivery fee calculation
Function<Order, Double> deliveryFee = order -> /* if free, return 0; else return distance * 3 */;

// Hint 4: Consumer for printing
Consumer<Order> printOrder = order -> System.out.println(/* format order details */);

Problem Set — Syntax, Programming, Industry & Interview

Syntax Questions (5)

1. Beginner Write the lambda expression equivalent of: Comparator<String> comp = new Comparator<String>() { public int compare(String a, String b) { return a.length() - b.length(); } };
2. Beginner What is the correct lambda syntax for a Runnable that prints "Hello Lambda"? Why are empty parentheses () required?
3. Intermediate Convert this lambda to a method reference: list.forEach(s -> System.out.println(s));
4. Intermediate Write a Predicate<String> lambda that returns true if a string has more than 5 characters AND starts with "A". Use the and() method.
5. Advanced Write a Function<Function<Integer,Integer>, Function<Integer,Integer>> lambda that takes a function and returns a new function that applies the original function twice. Example: if input is x -> x + 1, output should be x -> x + 2.

Programming Questions (8)

1. Beginner Write a Java program that sorts a list of Indian city names by length using a lambda expression with Comparator.
2. Beginner Create a custom functional interface Greeting with method String greet(String name). Implement it using a lambda that returns "Namaste, " + name + "!".
3. Intermediate Write a program using Predicate<Integer> that filters even numbers, then uses Function<Integer, Integer> to square them, and Consumer<Integer> to print results.
4. Intermediate Implement a Supplier<List<String>> that generates a list of 5 random Indian food items. Use it to populate and print 3 different menus.
5. Intermediate Write a program that uses all 4 types of method references (static, bound instance, constructor, arbitrary instance) in a single class.
6. Advanced Build a Function<List<Integer>, Map<String, List<Integer>>> that categorises numbers into "Even" and "Odd" groups using lambdas and streams.
7. Advanced Create a mini calculator using BiFunction<Double, Double, Double> stored in a Map<String, BiFunction> for operations: add, subtract, multiply, divide.
8. Advanced Write a chain of Functions using andThen() and compose() that: (1) trims a string, (2) converts to uppercase, (3) appends " — PROCESSED". Apply to a list of messy inputs.

Industry Questions (3)

1. Intermediate Swiggy uses lambdas in its pricing engine. Design the functional interfaces needed for: base price calculation, surge multiplier, coupon discount, and GST. Show how they chain together.
2. Advanced Flipkart's product recommendation engine filters products by category, price range, and rating. Design this using Predicate<Product> with and(), or(), and negate() chaining.
3. Advanced Razorpay processes payments through validation steps. Design a pipeline using Function.andThen() that: validates amount → checks fraud → applies charges → generates receipt.

Interview Questions (3)

1. Intermediate TCS/Infosys: "What is the difference between a lambda expression and an anonymous class? Can you always replace one with the other?"
2. Advanced Flipkart/Amazon: "Explain the concept of 'effectively final' in the context of lambda expressions. Why is this restriction necessary?"
3. Advanced Google/Microsoft: "What happens at the bytecode level when Java compiles a lambda expression? How is it different from an anonymous class?"

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Implement (Q11–Q15)

Analyze / Compare (Q16–Q20)

Evaluate / Justify (Q21–Q25)

Create / Design (Q26–Q30)

Short Answer Questions (8)

Q1. What is a functional interface? Give two examples from the Java standard library.

Answer: A functional interface is an interface with exactly one abstract method (SAM — Single Abstract Method). It can have any number of default and static methods. The @FunctionalInterface annotation can be used to enforce this at compile time.

Examples: (1) java.lang.Runnable with method void run(). (2) java.util.Comparator<T> with method int compare(T o1, T o2). Other examples include Predicate<T>, Function<T,R>, Consumer<T>, and Supplier<T>.

Q2. List three differences between a lambda expression and an anonymous class.

Answer:

Q3. Name and describe the four types of method references in Java.

Answer:

(1) Static method reference (ClassName::staticMethod) — references a static method, e.g., Integer::parseInt.
(2) Bound instance method reference (instance::method) — references a method on a specific object, e.g., System.out::println.
(3) Constructor reference (ClassName::new) — references a constructor, e.g., ArrayList::new.
(4) Arbitrary instance method reference (ClassName::instanceMethod) — references an instance method where the first argument becomes the receiver, e.g., String::toLowerCase.

Q4. What does "effectively final" mean? Why is this constraint imposed on lambda expressions?

Answer: A variable is "effectively final" if its value is assigned once and never modified, even without the explicit final keyword. Lambdas can only capture effectively final local variables because: (1) Lambdas may execute on a different thread than where the variable was declared, so modifying it would cause concurrency issues. (2) Lambdas capture a copy of the variable, not the variable itself — if the original changed, the lambda's copy would be stale.

Q5. What is the purpose of the @FunctionalInterface annotation? Is it mandatory?

Answer: The @FunctionalInterface annotation serves as a compile-time safeguard. If an interface annotated with it has more than one abstract method, the compiler throws an error. It also serves as documentation, clearly communicating the developer's intent that the interface is designed for lambda use. It is not mandatory — any interface with exactly one abstract method is automatically a functional interface and can be used with lambdas, even without the annotation.

Q6. How does Predicate<T> differ from Function<T, Boolean>?

Answer: Both can represent a boolean-returning function, but they differ: (1) Predicate<T> returns primitive boolean via test(T), avoiding autoboxing overhead. Function<T, Boolean> returns the wrapper Boolean via apply(T). (2) Predicate provides composition methods: and(), or(), negate(). Function provides andThen() and compose(). (3) Predicate is semantically clearer — it explicitly communicates "this is a boolean test." Use Predicate when testing conditions; use Function<T, Boolean> rarely, only when needed for generic Function pipelines.

Q7. Differentiate between a static nested class and a non-static inner class.

Answer:

Q8. When should you NOT use lambda expressions?

Answer: Avoid lambdas when: (1) Complex logic: If the lambda body exceeds 3–4 lines, extract it into a named method for readability. (2) Multiple abstract methods: The target interface has more than one abstract method (not a functional interface). (3) Need for this: When you need this to refer to the implementing object itself (lambdas' this refers to the enclosing class). (4) State management: When the implementation needs its own instance variables or constructor. (5) Extending abstract classes: Lambdas cannot extend abstract classes. (6) Debugging: Anonymous classes generate named .class files that appear in stack traces; lambda stack traces can be harder to read.

Long Answer Questions (3)

Q1. Trace the evolution from anonymous classes to lambda expressions in Java. Explain with code examples how the same functionality is expressed in both approaches, and discuss the advantages of lambdas.

Answer:

Before Java 8 — The Anonymous Class Era: Java used anonymous inner classes to pass behaviour as arguments. Consider sorting a list of employees by salary:

Java
// Step 1: Define the interface
interface SalaryComparator {
    int compare(Employee e1, Employee e2);
}

// Step 2: Anonymous class implementation (verbose!)
Collections.sort(employees, new Comparator<Employee>() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return Double.compare(e1.salary, e2.salary);
    }
});

Problems with anonymous classes: (1) Verbose boilerplate — 5 lines for 1 line of logic. (2) Poor readability — the actual comparison logic is buried. (3) Generates a separate .class file for each anonymous class. (4) this refers to the anonymous class, not the enclosing class, causing confusion.

Java 8 — Lambda Revolution:

Java
// Same sort — one line!
employees.sort((e1, e2) -> Double.compare(e1.salary, e2.salary));

// Even shorter with method reference
employees.sort(Comparator.comparingDouble(e -> e.salary));

Advantages of lambdas: (1) Conciseness: Reduces boilerplate by 70–90%. (2) Readability: The intent (comparison logic) is front and center. (3) Performance: Uses invokedynamic instead of generating anonymous class files — lighter on class loading. (4) Functional composition: Lambdas can be chained using andThen(), compose(), and(), or(). (5) Streams compatibility: Lambdas unlock the Streams API for declarative data processing.

Limitation: Lambdas can only replace anonymous classes implementing functional interfaces. For multi-method interfaces or abstract classes, anonymous classes are still required.

Q2. Explain the five core interfaces in java.util.function (Predicate, Function, Consumer, Supplier, BiFunction) with detailed code examples showing real-world usage.

Answer:

The java.util.function package, introduced in Java 8, provides standardised functional interfaces that eliminate the need to define custom interfaces for common patterns.

1. Predicate<T> — Tests a condition, returns boolean.

Java
Predicate<String> isValidEmail = email -> email.contains("@") && email.endsWith(".com");
Predicate<Integer> isEligibleAge = age -> age >= 18 && age <= 60;

// Chaining: Find eligible adults with valid email
// customers.stream().filter(isEligibleAge.and(hasValidEmail))...

2. Function<T, R> — Transforms input of type T into output of type R.

Java
Function<String, String> toSlug = name -> name.toLowerCase().replace(" ", "-");
Function<Double, String> formatPrice = price -> String.format("₹%.2f", price);

// Chaining: slug then prefix
Function<String, String> urlGenerator = toSlug.andThen(slug -> "/menu/" + slug);
System.out.println(urlGenerator.apply("Chicken Biryani")); // /menu/chicken-biryani

3. Consumer<T> — Processes input without returning anything (side effects).

Java
Consumer<Order> sendSMS = order -> System.out.println("SMS sent for " + order.id);
Consumer<Order> sendEmail = order -> System.out.println("Email sent for " + order.id);
Consumer<Order> notifyAll = sendSMS.andThen(sendEmail); // both notifications

4. Supplier<T> — Generates/supplies a value with no input.

Java
Supplier<LocalDateTime> now = LocalDateTime::now;
Supplier<String> uuid = () -> UUID.randomUUID().toString();
// Lazy initialisation, factory methods, default values

5. BiFunction<T, U, R> — Takes two arguments of types T and U, returns R.

Java
BiFunction<Double, Integer, Double> calculateGST =
    (amount, gstPercent) -> amount * gstPercent / 100;
System.out.println(calculateGST.apply(1000.0, 18)); // 180.0

Real-world pipeline: In a food delivery app, you'd use Predicate to filter eligible orders, Function to calculate prices, BiFunction for GST, and Consumer to print/send the final bill — all composable, all reusable.

Q3. Design a lambda-based event handling system for a food delivery application. Describe the architecture, define the functional interfaces needed, and implement core functionality with code.

Answer:

Architecture: An event-driven system where different events (ORDER_PLACED, ORDER_ACCEPTED, DELIVERY_STARTED, DELIVERED) trigger different handlers. Instead of using traditional Observer pattern with heavyweight classes, we use lambdas as lightweight event handlers.

Java
import java.util.*;
import java.util.function.Consumer;

class OrderEvent {
    String orderId, eventType, timestamp;
    Map<String, Object> data;

    OrderEvent(String orderId, String eventType) {
        this.orderId = orderId;
        this.eventType = eventType;
        this.timestamp = java.time.LocalDateTime.now().toString();
        this.data = new HashMap<>();
    }
}

class EventBus {
    // Map of event type → list of lambda handlers
    private Map<String, List<Consumer<OrderEvent>>> handlers = new HashMap<>();

    void subscribe(String eventType, Consumer<OrderEvent> handler) {
        handlers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(handler);
    }

    void publish(OrderEvent event) {
        handlers.getOrDefault(event.eventType, Collections.emptyList())
                .forEach(handler -> handler.accept(event));
    }
}

public class DeliveryEventSystem {
    public static void main(String[] args) {
        EventBus bus = new EventBus();

        // Register handlers as lambdas — no classes needed!
        bus.subscribe("ORDER_PLACED",
            e -> System.out.println("📧 SMS to customer: Order " + e.orderId + " placed!"));

        bus.subscribe("ORDER_PLACED",
            e -> System.out.println("🏪 Notify restaurant for " + e.orderId));

        bus.subscribe("DELIVERED",
            e -> System.out.println("⭐ Ask for rating: " + e.orderId));

        // Publish events
        bus.publish(new OrderEvent("SWG-001", "ORDER_PLACED"));
        bus.publish(new OrderEvent("SWG-001", "DELIVERED"));
    }
}

Why this works: Each handler is a Consumer<OrderEvent> — a lambda. No need for EventListener classes, Observer interfaces, or factory patterns. New behaviour is added by simply subscribing another lambda. This is the architecture used by modern event-driven systems at Swiggy, Razorpay, and Flipkart.

Lab Programs

No specific university lab program is mapped to Unit 10. Lab 2 — Multithreading via Lambda is covered in Unit 11.

Industry Spotlight — A Day in the Life

Earn With It — Functional Refactoring Services

⏱️ Time to First Earning: 3–4 weeks (if you complete Tier 3 lab, build a GitHub portfolio with 3 refactored projects, and create a Fiverr gig).

Chapter Summary

🐦 Code Tweet

Checkpoint — Self-Assessment

✅ Unit 10 complete. MCQs: 30. Ready for Unit 11!

[QR: Link to EduArtha video tutorial — Nested Classes & Lambda Expressions]