Java Method References Explained — Types, Use Cases and Pitfalls

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) {
            this.name = name;
            this.price = price;
        }

        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.*;
import java.util.stream.Collectors;

public class OrderProcessingPipeline {

    enum OrderStatus { PENDING, SHIPPED, DELIVERED, CANCELLED }

    static class Order {
        private final int orderId;
        private final String customerId;
        private final OrderStatus status;
        private final double totalAmount;

        public Order(int orderId, String customerId, OrderStatus status, double totalAmount) {
            this.orderId = orderId;
            this.customerId = customerId;
            this.status = status;
            this.totalAmount = totalAmount;
        }

        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.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
    }
}