Java Functional Interfaces — Checked Exception Lambda Crash

// @FunctionalInterface tells the compiler: "enforce the one-abstract-method rule"
@FunctionalInterface
interface Greeter {
    // This is the ONE abstract method — the 'shape' a lambda must fill
    String greet(String name);

    // Default methods are allowed — they don't count against the rule
    default String greetLoudly(String name) {
        return greet(name).toUpperCase();
    }

    // Static helpers are also fine
    static Greeter formal() {
        return name -> "Good day, " + name + ".";
    }
}

public class FunctionalInterfaceBasics {
    public static void main(String[] args) {

        // Lambda: a concise implementation of the single abstract method 'greet'
        Greeter casualGreeter = name -> "Hey, " + name + "!";

        // Method reference: another way to implement that same one method
        Greeter shoutGreeter = String::toUpperCase; // greet(name) -> name.toUpperCase()

        System.out.println(casualGreeter.greet("Alice"));

        // Default method works on top of our lambda implementation
        System.out.println(casualGreeter.greetLoudly("Alice"));

        // Static factory method returns a pre-built implementation
        Greeter formalGreeter = Greeter.formal();
        System.out.println(formalGreeter.greet("Bob"));
    }
}

import java.util.List;
import java.util.function.*;

public class BuiltInFunctionalInterfaces {

    record Order(String customerId, double totalAmount, boolean isPremiumMember) {}

    public static void main(String[] args) {

        List<Order> orders = List.of(
            new Order("C001", 120.00, true),
            new Order("C002", 40.00, false),
            new Order("C003", 250.00, false),
            new Order("C004", 85.00, true)
        );

        // --- PREDICATE: tests a condition, returns boolean ---
        // Does this order qualify for a discount?
        Predicate<Order> isHighValue = order -> order.totalAmount() > 100.0;
        Predicate<Order> isPremium   = order -> order.isPremiumMember();

        // Compose predicates: high-value OR premium member gets the discount
        Predicate<Order> qualifiesForDiscount = isHighValue.or(isPremium);

        System.out.println("=== Orders Qualifying for Discount ===");
        orders.stream()
              .filter(qualifiesForDiscount)        // Predicate plugs straight into filter()
              .forEach(o -> System.out.println("  " + o.customerId() + " — $" + o.totalAmount()));

        // --- FUNCTION: transforms T into R ---
        // Turn an Order into a human-readable receipt summary string
        Function<Order, String> toReceiptSummary =
            order -> String.format("Customer %s | Total: $%.2f | Premium: %s",
                                   order.customerId(),
                                   order.totalAmount(),
                                   order.isPremiumMember() ? "Yes" : "No");

        // andThen() chains a second transformation: summary -> uppercase alert
        Function<Order, String> toUrgentAlert = toReceiptSummary.andThen(String::toUpperCase);

        System.out.println("\n=== Urgent Alert for Largest Order ===");
        orders.stream()
              .max((a, b) -> Double.compare(a.totalAmount(), b.totalAmount()))
              .map(toUrgentAlert)                  // Function plugs into map()
              .ifPresent(System.out::println);

        // --- CONSUMER: takes input, returns nothing (side effects) ---
        // Log an order to an audit trail
        Consumer<Order> auditLogger =
            order -> System.out.println("  [AUDIT] Order processed: " + order.customerId());

        // andThen() lets you chain multiple consumers
        Consumer<Order> emailNotifier =
            order -> System.out.println("  [EMAIL] Receipt sent to " + order.customerId());

        Consumer<Order> fullOrderPipeline = auditLogger.andThen(emailNotifier);

        System.out.println("\n=== Processing Premium Orders ===");
        orders.stream()
              .filter(isPremium)
              .forEach(fullOrderPipeline);          // Consumer plugs into forEach()

        // --- SUPPLIER: no input, produces a value (lazy / factory) ---
        // Only create a default fallback order if we actually need one
        Supplier<Order> defaultOrderSupplier = () -> new Order("DEFAULT", 0.0, false);

        // orElseGet() accepts a Supplier — the lambda runs ONLY if no value is present
        Order result = orders.stream()
                             .filter(o -> o.customerId().equals("C999")) // Won't match anything
                             .findFirst()
                             .orElseGet(defaultOrderSupplier);

        System.out.println("\n=== Fallback Order ===");
        System.out.println("  Resolved customer: " + result.customerId());
    }
}

import java.util.function.*;
import java.util.*;

public class BiFunctionalInterfaces {

    record Transaction(String accountId, double amount) {}
    record Customer(double creditLimit, boolean isActive) {}

    public static void main(String[] args) {

        // --- BiFunction: combine two inputs into one result ---
        // Given a transaction and a customer, compute the allowed debit
        BiFunction<Transaction, Customer, Double> allowedDebit =
            (txn, customer) -> {
                if (!customer.isActive()) return 0.0;
                return Math.min(txn.amount(), customer.creditLimit());
            };

        Transaction txn = new Transaction("ACC-001", 5000.0);
        Customer cust = new Customer(3000.0, true);
        double allowed = allowedDebit.apply(txn, cust);
        System.out.println("Allowed debit: $" + allowed);  // $3000.0 (capped by credit limit)

        // --- BiPredicate: test a condition on two objects ---
        BiPredicate<Transaction, Customer> canProcess =
            (t, c) -> c.isActive() && t.amount() <= c.creditLimit();

        System.out.println("Can process: " + canProcess.test(txn, cust));  // true

        // Combine BiPredicates with and()
        BiPredicate<Transaction, Customer> isLarge = (t, c) -> t.amount() > 1000;
        BiPredicate<Transaction, Customer> flagged = canProcess.and(isLarge);
        System.out.println("Large & processable: " + flagged.test(txn, cust));  // true (both conditions met)

        // --- BiConsumer: consume two arguments (side effect) ---
        // Log a transaction with customer info
        BiConsumer<Transaction, Customer> auditLog =
            (t, c) -> System.out.printf("[AUDIT] Account %s: $%.2f request by active=%s%n",
                                        t.accountId(), t.amount(), c.isActive());

        BiConsumer<Transaction, Customer> slackAlert =
            (t, c) -> System.out.printf("[SLACK] Large transaction: %s $%.2f%n",
                                        t.accountId(), t.amount());

        // Chain BiConsumers with andThen()
        BiConsumer<Transaction, Customer> pipeline = auditLog.andThen(slackAlert);
        pipeline.accept(txn, cust);
    }
}

import java.util.function.*;
import java.util.stream.IntStream;

public class PrimitiveFunctionalInterfaces {

    public static void main(String[] args) {

        // --- IntFunction: takes int, returns String ---
        IntFunction<String> numberToLabel = id -> "Item #" + id;
        System.out.println(numberToLabel.apply(42));  // Item #42

        // --- ToIntFunction: takes String, returns int ---
        ToIntFunction<String> stringLength = String::length;
        System.out.println(stringLength.applyAsInt("Hello"));  // 5

        // --- IntToDoubleFunction: int → double ---
        IntToDoubleFunction celsiusToFahrenheit = c -> c * 9.0 / 5.0 + 32;
        System.out.println(celsiusToFahrenheit.applyAsDouble(100));  // 212.0

        // --- IntPredicate: int → boolean ---
        IntPredicate isEven = n -> n % 2 == 0;
        long count = IntStream.range(1, 100).filter(isEven).count();
        System.out.println("Even numbers 1-99: " + count);  // 49

        // --- IntUnaryOperator: int → int (avoid boxing in a hot loop) ---
        IntUnaryOperator square = n -> n * n;
        int sum = IntStream.range(1, 1000)
                           .map(square)
                           .sum();
        System.out.println("Sum of squares 1-999: " + sum);
    }
}

import java.util.function.*;
import java.util.*;
import java.util.stream.*;

public class OperatorSpecializations {

    public static void main(String[] args) {

        // --- UnaryOperator: T → T ---
        UnaryOperator<String> toUpper = String::toUpperCase;
        UnaryOperator<String> addExclamation = s -> s + "!";

        // Compose: first uppercase, then add exclamation
        UnaryOperator<String> shout = toUpper.andThen(addExclamation);
        System.out.println(shout.apply("hello"));  // HELLO!

        // Use with Stream.map — semantically clearer than Function<String,String>
        List<String> names = List.of("alice", "bob", "carol");
        List<String> shouted = names.stream()
                                    .map(shout)
                                    .collect(Collectors.toList());
        System.out.println(shouted);  // [ALICE!, BOB!, CAROL!]

        // --- BinaryOperator: (T, T) → T ---
        BinaryOperator<Integer> sum = Integer::sum;
        BinaryOperator<Integer> max = Integer::max;

        // Reduction: find sum and max of a list
        List<Integer> numbers = List.of(10, 25, 3, 47, 18);
        int total = numbers.stream().reduce(0, sum);
        int biggest = numbers.stream().reduce(max).orElse(0);
        System.out.println("Sum: " + total + ", Max: " + biggest);  // Sum: 103, Max: 47

        // Custom BinaryOperator: merge two strings with an ellipsis
        BinaryOperator<String> merge = (a, b) -> a + "..." + b;
        String merged = merge.apply("Hello", "World");
        System.out.println(merged);  // Hello...World
    }
}

// Problem 1: Filter and Transform
import java.util.*;
import java.util.function.*;
import java.util.stream.*;

class PracticeProblems {

    record Employee(String name, String dept, double salary) {}

    public static void problem1() {
        List<Employee> employees = List.of(
            new Employee("Alice", "Engineering", 95000),
            new Employee("Bob", "Marketing", 72000),
            new Employee("Carol", "Engineering", 110000)
        );

        Predicate<Employee> isEngineer = e -> e.dept.equals("Engineering");
        Function<Employee, String> format = e -> "Name: " + e.name + ", Salary: " + e.salary;

        List<String> result = employees.stream()
            .filter(isEngineer)
            .map(format)
            .collect(Collectors.toList());

        System.out.println(result);
    }

    // Problem 2: Consumer Pipeline
    record Order(String id, double amount) {}

    public static void problem2() {
        List<Order> orders = List.of(
            new Order("ORD001", 250.0),
            new Order("ORD002", 50.0)
        );

        Consumer<Order> log = o -> System.out.println("[LOG] Order " + o.id);
        Consumer<Order> email = o -> System.out.println("[EMAIL] Sending receipt for " + o.id);
        java.util.concurrent.atomic.AtomicInteger counter = new java.util.concurrent.atomic.AtomicInteger(0);
        Consumer<Order> count = o -> counter.incrementAndGet();

        Consumer<Order> pipeline = log.andThen(email).andThen(count);
        orders.forEach(pipeline);
        System.out.println("Processed: " + counter.get());
    }

    // Problem 3: Custom Interface with Checked Exception
    @FunctionalInterface
    interface DataLoader {
        String load(String path) throws Exception;
    }

    public static void problem3() throws Exception {
        DataLoader fileLoader = path -> {
            // Simulate file reading
            if (path.equals("config.txt")) return "config data";
            throw new IOException("File not found: " + path);
        };
        System.out.println(fileLoader.load("config.txt"));
    }

    // Problem 4: BiPredicate Validation
    record Transaction(double amount, String merchant, boolean isBusinessHours) {}

    public static void problem4() {
        Set<String> blacklist = Set.of("SuspiciousMerchant", "FraudInc");
        BiPredicate<Transaction, Set<String>> amountCheck = (txn, bl) -> txn.amount > 10000;
        BiPredicate<Transaction, Set<String>> merchantCheck = (txn, bl) -> bl.contains(txn.merchant);
        BiPredicate<Transaction, Set<String>> hoursCheck = (txn, bl) -> txn.isBusinessHours;

        BiPredicate<Transaction, Set<String>> suspicious = amountCheck.and(merchantCheck).and(hoursCheck);
        Transaction txn = new Transaction(15000, "SuspiciousMerchant", true);
        System.out.println("Suspicious: " + suspicious.test(txn, blacklist));
    }

    // Problem 5: Primitive Specialisation
    public static void problem5() {
        int[] data = new int[10_000_000];
        Arrays.fill(data, 2); // Fill with 2 so squares are 4

        // IntUnaryOperator (no boxing)
        IntUnaryOperator squareInt = x -> x * x;
        long start = System.nanoTime();
        long sum = Arrays.stream(data).map(squareInt).asLongStream().sum();
        long end = System.nanoTime();
        System.out.println("Primitive: sum=" + sum + " time=" + (end-start)/1_000_000 + "ms");

        // Function<Integer,Integer> (boxing)
        Function<Integer, Integer> squareBoxed = x -> x * x;
        start = System.nanoTime();
        long sumBoxed = Arrays.stream(data).boxed()
                              .map(squareBoxed)
                              .mapToLong(Integer::longValue)
                              .sum();
        end = System.nanoTime();
        System.out.println("Boxed: sum=" + sumBoxed + " time=" + (end-start)/1_000_000 + "ms");
    }

    public static void main(String[] args) throws Exception {
        problem1();
        problem2();
        problem3();
        problem4();
        problem5();
    }
}

// io.thecodeforge
import java.util.function.Predicate;

@FunctionalInterface
interface OrderValidator {
    boolean isValid(Order order);
    
    // default methods are allowed
    default String validationName() {
        return "BaseValidator";
    }
    
    // static methods are allowed
    static OrderValidator combine(OrderValidator a, OrderValidator b) {
        return order -> a.isValid(order) && b.isValid(order);
    }
}

// Uncommenting below line? Compiler screams.
// void anotherMethod();

public class ValidationRunner {
    public static void main(String[] args) {
        OrderValidator notExpired = order -> order.expiryDate().isAfter(LocalDate.now());
        OrderValidator sufficientQuantity = order -> order.quantity() > 0;
        
        OrderValidator combined = OrderValidator.combine(notExpired, sufficientQuantity);
        
        Order testOrder = new Order(LocalDate.now().plusDays(1), 5);
        System.out.println("Order valid: " + combined.isValid(testOrder));
    }
}

record Order(LocalDate expiryDate, int quantity) {}

// io.thecodeforge
import java.util.function.*;

// BEFORE Java 8 — anonymous inner class hell
class LegacyProcessor {
    void process(Order order, Consumer<Order> callback) {
        if (order.amount() > 1000) {
            callback.accept(order); // some callback
        }
    }
}

// Calling it: 8 lines for one action
public class Main {
    public static void main(String[] args) {
        LegacyProcessor legacy = new LegacyProcessor();
        legacy.process(new Order(1500), new Consumer<Order>() {
            @Override
            public void accept(Order order) {
                System.out.println("Legacy: High-value order " + order.amount());
            }
        });
        
        // AFTER Java 8 — lambda, 1 line
        java.util.function.Consumer<Order> modern = order -> 
            System.out.println("Modern: High-value order " + order.amount());
        modern.accept(new Order(1500));
    }
}

record Order(int amount) {}