Java Method References — The Mutable Logger Bug

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

public class MethodReferenceMotivation {

    public static void main(String[] args) {
        List<String> employeeNames = Arrays.asList(
            "Priya", "carlos", "AMARA", "benjamin", "Liu"
        );

        // Lambda version — correct, but the arrow and parameters are just noise here.
        // The reader has to parse the lambda to realise it only calls toUpperCase().
        List<String> uppercasedWithLambda = employeeNames.stream()
            .map(name -> name.toUpperCase())   // boilerplate wrapping a single method call
            .collect(Collectors.toList());

        // Method reference version — reads out loud as "map each name to its uppercase form".
        // The compiler produces identical bytecode for both versions.
        List<String> uppercasedWithRef = employeeNames.stream()
            .map(String::toUpperCase)           // direct pointer to the method — no noise
            .collect(Collectors.toList());

        // Both lists are identical
        System.out.println("Lambda result:     " + uppercasedWithLambda);
        System.out.println("Reference result:  " + uppercasedWithRef);
        System.out.println("Results equal?     " + uppercasedWithLambda.equals(uppercasedWithRef));
    }
}

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

public class AllFourMethodReferenceTypes {

    // A simple domain class we'll use throughout
    static class Product {
        private final String name;
        private final double price;

        public Product(String name) {
            // Constructor reference target — accepts one String arg
            this.name = name;
            this.price = 0.0;
        }

        public Product(String name, double price) {\n            this.name = name;\n            this.price = price;\n        }

        public String getName() { return name; }
        public double getPrice() { return price; }

        // Static helper — a natural candidate for a static method reference
        public static boolean isAffordable(Product product) {
            return product.getPrice() < 50.0;
        }

        @Override
        public String toString() {
            return name + "($" + price + ")";
        }
    }

    public static void main(String[] args) {

        // ── TYPE 1: Static method reference ──────────────────────────────────
        // Predicate<Product> expects a method that takes a Product and returns boolean.
        // Product::isAffordable matches that signature perfectly.
        Predicate<Product> affordableFilter = Product::isAffordable;

        List<Product> inventory = Arrays.asList(
            new Product("Notebook", 12.99),
            new Product("Mechanical Keyboard", 89.99),
            new Product("USB Hub", 24.99),
            new Product("Monitor", 349.99)
        );

        List<Product> affordableItems = inventory.stream()
            .filter(Product::isAffordable)   // static ref: no instance needed
            .collect(Collectors.toList());
        System.out.println("Affordable: " + affordableItems);


        // ── TYPE 2: Instance method on an ARBITRARY instance ──────────────────
        // String::toLowerCase — the String instance is whatever flows through the stream.
        // The compiler maps this to Function<String, String>: name -> name.toLowerCase()
        List<String> productNames = Arrays.asList("WIDGET", "GADGET", "DOOHICKEY");
        List<String> lowercaseNames = productNames.stream()
            .map(String::toLowerCase)        // instance ref on arbitrary receiver
            .collect(Collectors.toList());
        System.out.println("Lowercase names: " + lowercaseNames);


        // ── TYPE 3: Instance method on a SPECIFIC instance ────────────────────
        // System.out is the specific PrintStream object. println is called on THAT object.
        // Every item in the stream gets printed via the same System.out instance.
        System.out.println("--- Printing with specific instance ref ---");
        inventory.stream()
            .map(Product::getName)
            .forEach(System.out::println);   // System.out is the fixed receiver


        // ── TYPE 4: Constructor reference ─────────────────────────────────────
        // Function<String, Product> needs a method that takes a String and returns a Product.
        // Product::new (the single-arg constructor) matches that signature.
        Function<String, Product> productFactory = Product::new;

        List<String> newProductNames = Arrays.asList("Webcam", "Mousepad", "Headset");
        List<Product> newProducts = newProductNames.stream()
            .map(Product::new)               // constructor ref creates a new Product per name
            .collect(Collectors.toList());
        System.out.println("New products: " + newProducts);
    }
}

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

public class MethodReferenceTableExamples {
    public static void main(String[] args) {
        // Type 1: Static method reference
        Function<String, Integer> staticRef = Integer::parseInt;
        System.out.println(staticRef.apply("100")); // 100

        // Type 2: Instance method on arbitrary instance
        Predicate<String> arbitraryRef = String::isEmpty;
        System.out.println(arbitraryRef.test("")); // true

        // Type 3: Instance method on specific instance
        StringBuilder sb = new StringBuilder();
        Consumer<String> specificRef = sb::append;
        specificRef.accept("Hello ");
        specificRef.accept("World!");
        System.out.println(sb); // Hello World!

        // Type 4: Constructor reference
        Supplier<List<String>> constructorRef = ArrayList::new;
        List<String> list = constructorRef.get();
        System.out.println(list.isEmpty()); // true
    }
}

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

public class LambdaVsMethodReference {
    static class Employee {
        private final String name;
        private final int salary;

        public Employee(String name, int salary) {\n            this.name = name;\n            this.salary = salary;\n        }

        public String getName() { return name; }
        public int getSalary()  { return salary; }

        public static String formatEntry(Employee e) {
            return e.getName() + ": $" + e.getSalary();
        }
    }

    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("Alice", 120000),
            new Employee("Bob",   95000),
            new Employee("Carol", 110000)
        );

        // Lambda version — works but method reference is cleaner
        List<String> lambdaNames = employees.stream()
            .map(e -> e.getName())
            .collect(Collectors.toList());

        // Method reference version — removes parameter noise
        List<String> refNames = employees.stream()
            .map(Employee::getName)
            .collect(Collectors.toList());

        // Use a lambda when logic is more than a single call:
        // Here we combine fields and add formatting — no single method does this.
        List<String> formatted = employees.stream()
            .map(e -> e.getName() + " earns $" + e.getSalary())
            .collect(Collectors.toList());

        System.out.println(lambdaNames);
        System.out.println(refNames);
        System.out.println(formatted);
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class OrderProcessingPipeline {

    enum OrderStatus { PENDING, SHIPPED, DELIVERED, CANCELLED }

    static class Order {\n        private final int orderId;\n        private final String customerId;\n        private final OrderStatus status;\n        private final double totalAmount;\n\n        public Order(int orderId, String customerId, OrderStatus status, double totalAmount) {\n            this.orderId = orderId;\n            this.customerId = customerId;\n            this.status = status;\n            this.totalAmount = totalAmount;\n        }

        public int getOrderId()         { return orderId; }
        public String getCustomerId()   { return customerId; }
        public OrderStatus getStatus()  { return status; }
        public double getTotalAmount()  { return totalAmount; }

        // Business logic lives in the domain object — makes method references meaningful
        public boolean isPending()      { return status == OrderStatus.PENDING; }
        public boolean isHighValue()    { return totalAmount > 200.0; }

        // Static factory helper — useful as a static method reference
        public static String formatOrderSummary(Order order) {
            return String.format("Order #%d | Customer: %s | $%.2f",
                order.orderId, order.customerId, order.totalAmount);
        }

        @Override
        public String toString() {
            return "Order #" + orderId;
        }
    }

    public static void main(String[] args) {
        List<Order> allOrders = Arrays.asList(
            new Order(101, "cust-A", OrderStatus.PENDING,   450.00),
            new Order(102, "cust-B", OrderStatus.SHIPPED,   89.99),
            new Order(103, "cust-A", OrderStatus.PENDING,   30.00),
            new Order(104, "cust-C", OrderStatus.CANCELLED, 210.00),
            new Order(105, "cust-B", OrderStatus.PENDING,   375.50),
            new Order(106, "cust-D", OrderStatus.DELIVERED, 95.00)
        );

        // ── Pipeline 1: Find unique customers with high-value pending orders ──
        // Each step uses a method reference — the pipeline reads like a sentence.
        List<String> priorityCustomers = allOrders.stream()
            .filter(Order::isPending)          // Type 2: arbitrary instance method
            .filter(Order::isHighValue)        // Type 2: another business rule
            .map(Order::getCustomerId)         // Type 2: extract the field we need
            .distinct()                        // built-in — no method ref needed
            .sorted()                          // natural sort on String
            .collect(Collectors.toList());

        System.out.println("Priority customers: " + priorityCustomers);

        // ── Pipeline 2: Format summaries and print them ───────────────────────
        // Mixes a static method reference (formatOrderSummary) with a specific
        // instance reference (System.out::println). Clean and expressive.
        System.out.println("\nHigh-value pending order summaries:");
        allOrders.stream()
            .filter(Order::isPending)
            .filter(Order::isHighValue)
            .map(Order::formatOrderSummary)    // Type 1: static method reference
            .forEach(System.out::println);     // Type 3: specific instance (System.out)

        // ── Pipeline 3: When a LAMBDA is the right call (not a method reference) ──
        // We need to combine two fields — no single method does this, so a lambda wins.
        double totalPendingRevenue = allOrders.stream()
            .filter(Order::isPending)          // method ref for the predicate — clean
            .mapToDouble(order -> order.getTotalAmount() * 1.10) // lambda — applying tax logic
            .sum();

        System.out.printf("%nTotal pending revenue (incl. 10%% tax): $%.2f%n", totalPendingRevenue);
    }
}

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

public class ConstructorReferencesDemo {
    static class Customer {
        private final String name;
        private final double creditLimit;

        // Zero-arg constructor
        public Customer() {
            this.name = "unknown";
            this.creditLimit = 0.0;
        }

        // One-arg constructor
        public Customer(String name) {
            this.name = name;
            this.creditLimit = 1000.0;
        }

        // Two-arg constructor
        public Customer(String name, double creditLimit) {\n            this.name = name;\n            this.creditLimit = creditLimit;\n        }

        // Static factory method — compare with constructor reference
        public static Customer createFromString(String data) {
            String[] parts = data.split(":");
            return new Customer(parts[0], Double.parseDouble(parts[1]));
        }

        @Override
        public String toString() {
            return name + "($" + creditLimit + ")";
        }
    }

    public static void main(String[] args) {
        // ── Supplier: zero-arg constructor ────────────────────────────────────
        Supplier<Customer> defaultCustomerFactory = Customer::new;
        Customer defaultCustomer = defaultCustomerFactory.get();
        System.out.println("Default: " + defaultCustomer);

        // ── Function: one-arg constructor ─────────────────────────────────────
        Function<String, Customer> namedCustomerFactory = Customer::new;
        List<String> names = Arrays.asList("Alice", "Bob", "Carol");
        List<Customer> customers = names.stream()
            .map(Customer::new)           // constructor reference
            .collect(Collectors.toList());
        System.out.println("Named: " + customers);

        // ── BiFunction: two-arg constructor ───────────────────────────────────
        BiFunction<String, Double, Customer> customFactory = Customer::new;
        Customer custom = customFactory.apply("Eve", 2500.0);
        System.out.println("Custom: " + custom);

        // ── When NOT to use constructor reference ─────────────────────────────
        // If the constructor doesn't exactly match the input format,
        // a lambda with explicit logic is clearer.
        List<String> rawData = Arrays.asList("Alice:1200", "Bob:800");
        List<Customer> parsed = rawData.stream()
            .map(Customer::createFromString)   // static method reference
            .collect(Collectors.toList());
        System.out.println("Parsed from string: " + parsed);

        // ── Common pitfall: ambiguous constructors ────────────────────────────
        // The following would cause a compile error because both one-arg and
        // two-arg constructors could be intended:
        // var ambiguous = Customer::new; // ERROR: reference to constructor is ambiguous
        // Solution: assign to a specific functional interface variable:
        Function<String, Customer> unambiguous = Customer::new;
    }
}

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

public class MethodReferenceGotchas {

    // ── Gotcha 1 Demo: Overload ambiguity ────────────────────────────────────
    static class Formatter {
        // Two overloads — if we reference format(Object) vs format(String), the
        // compiler must infer from context. When context is ambiguous, it fails.
        public static String format(String value)  { return "[String: " + value + "]"; }
        public static String format(Integer value) { return "[Integer: " + value + "]"; }
    }

    // ── Gotcha 2 Demo: Mutable captured instance ──────────────────────────────
    static class ReportPrinter {
        private String prefix;

        public ReportPrinter(String prefix) { this.prefix = prefix; }
        public void setPrefix(String prefix) { this.prefix = prefix; }
        public void printLine(String line)   { System.out.println(prefix + line); }
    }

    public static void main(String[] args) {

        // ── Gotcha 1: Overload resolved by context ────────────────────────────
        // This compiles fine — Function<String, String> pins the compiler to format(String)
        Function<String, String> stringFormatter = Formatter::format;
        System.out.println(stringFormatter.apply("hello"));

        // This also compiles — Function<Integer, String> pins it to format(Integer)
        Function<Integer, String> intFormatter = Formatter::format;
        System.out.println(intFormatter.apply(42));

        // The compiler would FAIL if you tried to assign Formatter::format to a raw
        // Function without type parameters — it can't choose between the two overloads.
        // Uncommenting the line below causes: 'reference to format is ambiguous'
        // Function rawFormatter = Formatter::format; // ← COMPILE ERROR


        // ── Gotcha 2: Mutable captured instance ───────────────────────────────
        ReportPrinter printer = new ReportPrinter("INFO: ");

        // We capture printer::printLine at this point in time.
        // The reference holds a pointer to the `printer` OBJECT, not a snapshot of its state.
        Consumer<String> logLine = printer::printLine;

        logLine.accept("System started");    // uses prefix = "INFO: "

        // Now we mutate the captured object's state
        printer.setPrefix("WARNING: ");      // the same object, different state

        // The method reference still points to the same `printer` object.
        // So it now uses the NEW prefix — not the one from when we created the reference.
        logLine.accept("Disk space low");    // uses prefix = "WARNING: "

        // ── Correct pattern when you need stable state ─────────────────────────
        // Create the reference AFTER the object is in its final state, or use an
        // immutable object to avoid surprises.
        ReportPrinter stablePrinter = new ReportPrinter("DEBUG: ");
        Consumer<String> stableLog = stablePrinter::printLine;
        // stablePrinter is never mutated after this — the reference is predictable.
        stableLog.accept("Connection established");


        // ── Gotcha 3: Confusing Type 2 with Type 1 ───────────────────────────
        // String::valueOf looks like a static ref (and it is — valueOf is static on String).
        // But String::isEmpty looks the same and is an instance method on an arbitrary receiver.
        // The compiler handles both — but beginners often don't realise these are different types.
        List<Object> mixedData = Arrays.asList(1, 2.5, "three", true);
        mixedData.stream()
            .map(String::valueOf)           // Type 1 — static: String.valueOf(item)
            .forEach(System.out::println);  // Type 3 — specific instance: System.out
    }
}

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

public class MethodReferenceInheritance {

    static class ListProcessor {
        void process(List<?> list) {
            System.out.println("Base: processing " + list.size() + " items");
        }
    }

    static class SpecializedProcessor extends ListProcessor {
        @Override
        void process(List<?> list) {
            System.out.println("Specialized: processing " + list + " with extra logic");
        }
    }

    public static void main(String[] args) {
        // Method reference on the base class — but it will call the overridden version
        // if the receiver is a subclass instance.
        Consumer<List<?>> processor = ListProcessor::process;

        List<String> items = Arrays.asList("a", "b", "c");

        // Using a base class instance: works as expected
        processor.accept(new ListProcessor());   // prints "Base: processing 3 items"

        // Using a subclass instance: the method reference dispatches polymorphically
        processor.accept(new SpecializedProcessor());   // prints "Specialized: ..."

        // If you really need to force the base implementation, use a lambda with a cast.
        // But this is rarely the right approach — rethink your design.
        Consumer<List<?>> forcedBase = list -> ((ListProcessor) new SpecializedProcessor()).process(list);
        forcedBase.accept(items);  // prints "Base: processing 3 items"
    }
}

// io.thecodeforge — java tutorial

import java.util.function.Function;

public class ReflectionOpaqueReference {
    public String transform(String input) {
        return input.toUpperCase();
    }

    public static void main(String[] args) {
        var instance = new ReflectionOpaqueReference();
        
        // Method reference — can't introspect the target method
        Function<String, String> ref = instance::transform;
        
        // This prints something like: ReflectionOpaqueReference$$Lambda/0x...
        System.out.println(ref.getClass().getName());
        
        // There's no getMethod() or getDeclaringClass() on that object
        // Trying to use it in a reflective validator will crash at runtime
    }
}

// io.thecodeforge — java tutorial

import java.io.*;
import java.util.function.Function;

public class SerializationFail {
    public static void main(String[] args) throws Exception {
        // Static method reference — looks safe, but isn't
        Function<String, String> ref = String::toUpperCase;
        
        byte[] serialized;
        try (var bos = new ByteArrayOutputStream();
             var oos = new ObjectOutputStream(bos)) {
            oos.writeObject(ref);
            serialized = bos.toByteArray();
        } catch (NotSerializableException e) {
            System.err.println("Boom: " + e.getMessage());
        }
    }
}

// io.thecodeforge — java tutorial

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

public class PerformanceTest {
    private int threshold = 10;
    
    public boolean isHigh(int value) { return value > threshold; }
    
    public void run() {
        var values = new ArrayList<Integer>();
        for (int i = 0; i < 1_000_000; i++) values.add(i);
        
        long start = System.nanoTime();
        for (int i = 0; i < 100; i++) {
            // Method reference — hidden capture of 'this'
            values.stream().filter(this::isHigh).count();
        }
        System.out.println("Method ref: " + (System.nanoTime() - start)/1e6 + " ms");
    }
    
    public static void main(String[] args) {
        new PerformanceTest().run();
    }
}

// io.thecodeforge — java tutorial

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

public class MethodReferenceLimit {
    public static void main(String[] args) {
        List<String> names = Arrays.asList(" a ", " b ", " c ");

        // Works: single unmodified method call
        names.forEach(System.out::println);

        // FAILS: need chaining — must use lambda
        // names.forEach(String::trim.toLowerCase); // compile error
        names.forEach(s -> System.out.println(s.trim().toLowerCase()));

        // FAILS: overload ambiguity
        // Comparator<String> c = String::compareTo; // ambiguous
        Comparator<String> c = (a, b) -> a.compareTo(b); // explicit
    }
}

// io.thecodeforge — java tutorial

import java.util.function.*;

public class MethodReferenceDecision {
    public static void main(String[] args) {
        // YES: single direct call
        Function<String, Integer> f1 = Integer::parseInt;

        // NO: argument is transformed
        Function<String, Integer> f2 = s -> Integer.parseInt(s.trim());

        // Constructor ref: clear exception
        Supplier<StringBuilder> f3 = StringBuilder::new;

        System.out.println(f1.apply("42"));
        System.out.println(f2.apply(" 99 "));
        System.out.println(f3.get().append("ok"));
    }
}

// io.thecodeforge — java tutorial
// Four types of method references
List<String> names = List.of("Alice", "Bob");

// 1. Static method reference
names.forEach(num -> System.out.println(num)); // lambda
names.forEach(System.out::println);          // method ref

// 2. Instance method on a parameter
names.stream().map(s -> s.length());          // lambda
names.stream().map(String::length);           // method ref

// 3. Instance method on an arbitrary object
names.forEach(System.out::println);           // method ref

// 4. Constructor reference
Supplier<List<String>> sup = ArrayList::new;  // method ref
List<String> list = sup.get();