Method References — The Four Forms and Their Lambda Equivalents

Method references are a compact lambda syntax for the case where the lambda just calls an existing method. The :: operator separates the type/instance from the method name. There are four forms:

1. Static method reference — `ClassName::staticMethod`

• Refers to a static method of a class
• Example: Integer::parseInt, equivalent to s -> Integer.parseInt(s)
• Other examples: Math::max, Objects::requireNonNull, String::valueOf
• Lambda parameters become method arguments, in order

2. Bound instance method reference — `instance::method`

• Receiver is captured at the moment the reference is created
• Example: System.out::println, equivalent to s -> System.out.println(s)
• The System.out PrintStream is captured; lambda parameters are method arguments
• Other examples: userRepo::save, cache::get, logger::error
• Be careful: if the receiver is null at creation time, you get NPE immediately

3. Unbound instance method reference — `ClassName::instanceMethod`

• The first lambda parameter becomes the receiver
• Example: String::toUpperCase, equivalent to s -> s.toUpperCase()
• BiFunction example: String::equalsIgnoreCase is (a, b) -> a.equalsIgnoreCase(b) — first arg is receiver, second is method argument
• Common in stream maps: User::getName, Order::getTotal

4. Constructor reference — `ClassName::new`

• Refers to a constructor; the compiler picks the overload by parameter count
• ArrayList::new is a Supplier for the no-arg constructor
• User::new could match Function for User(String) or BiFunction for User(String, String)
• Array constructor: String[]::new is IntFunction for stream.toArray(...)

Bound vs unbound — the trickiest distinction

String s = "hello";
Supplier<Integer> bound = s::length;       // s captured, no args
Function<String, Integer> unbound = String::length;  // arg becomes receiver

• Bound: looks like instance::method — receiver fixed
• Unbound: looks like Class::method and method is an instance method — first arg is receiver
• Static: looks like Class::method and method is a static method

The compiler disambiguates based on whether the method is static and what target functional interface is expected.

Lambda vs method reference — when to use which

Use method reference when:

• The lambda just calls one method
• The method name is self-documenting
• Common cases: User::getName, Objects::nonNull, String::isEmpty, System.out::println

Use lambda when:

• You need to rearrange parameters
• You need multiple operations
• You need to add a constant
• The method-reference form is ambiguous

Performance

• Method references are usually as fast or marginally faster than lambdas
• Non-capturing static and unbound references are cached — zero allocation per call
• Bound references capture the receiver — one allocation per capture (small cost)
• Constructor references in hot paths: watch allocation; usually fine

Pitfalls

• Bound vs unbound confusion — the most common interview trap
• Ambiguous overloads — if multiple methods match the target signature, the compiler errors out; sometimes you need a lambda for explicit disambiguation
• `null` receiver in bound reference — NPE at creation time; the receiver is evaluated eagerly
• Mutable captured receiver — bound reference holds the instance reference; if it mutates, behavior changes

Recommendation: Use method references as the default when the lambda just calls one method — they read better, document intent, and are sometimes faster. Stick with lambdas when you need parameter rearrangement, multiple operations, or to add constants. The trickiest case is bound vs unbound — remember the rule: instance::method is bound (receiver fixed), Class::method on an instance method is unbound (first arg becomes receiver). For constructor references, the compiler picks the overload by parameter count, so User::new can be a Supplier, a Function, or a BiFunction depending on context. Trust your IDE's hints — IntelliJ and Eclipse will suggest converting x -> foo(x) to this::foo or MyClass::foo automatically; usually accept those unless the lambda was doing something non-trivial.