method references

the picture

you know how half your lambdas end up as x -> something(x)? the lambda adds nothing except a name for the argument, which you immediately hand to someone else. a method reference skips the middleman.

think of a speed dial. instead of writing out the number every time (the lambda body), you point at a contact that's already saved (the method). the phone knows how to dial it.

all four, running

import java.util.*;
import java.util.function.*;
 
void main() {
    // 1. static: Class::staticMethod
    Function<String, Integer> parse = Integer::parseInt;   // s -> Integer.parseInt(s)
    // 2. bound: expression::method, the receiver is fixed right now
    String greeting = "hello";
    Predicate<String> starts = greeting::startsWith;   // p -> greeting.startsWith(p)
    // 3. unbound: Class::instanceMethod, the first argument is the receiver
    Function<String, Integer> len = String::length;    // s -> s.length()
    Comparator<String> cmp = String::compareToIgnoreCase;
                                         // (a, b) -> a.compareToIgnoreCase(b)
    // 4. constructor: Class::new (arrays too)
    Supplier<List<String>> fresh = ArrayList::new;     // () -> new ArrayList<>()
    IntFunction<int[]> array = int[]::new;             // n -> new int[n]
 
    IO.println(parse.apply("42") + 1);
    IO.println(starts.test("hell"));
    IO.println(len.apply("duke"));
    IO.println(cmp.compare("JAVA", "java"));
    IO.println(fresh.get());
    IO.println(array.apply(3).length);
}

43
true
4
0
[]
3

the same :: text can mean different things depending on the target. String::compareToIgnoreCase takes one argument as a method, but as a Comparator<String> it takes two: the first one becomes the object the method is called on. that's the unbound trick, and it's why list.sort(String::compareToIgnoreCase) works.

sort them yourself

the only hard part is telling bound from unbound. the question to ask: is there an actual object to the left of ::, or just a class name?

when the receiver gets evaluated

here's the subtle difference between a bound reference and the lambda you'd write by hand. the lambda evaluates sb every time it runs. the method reference evaluates sb once, when the reference is created, and keeps that object.

StringBuilder sb = new StringBuilder("a");
Supplier<String> snap = sb::toString;
sb = new StringBuilder("b");
IO.println(snap.get());

that also means a null receiver blows up early, at creation, not when you call it:

import java.util.function.*;
 
void main() {
    String name = null;
    Supplier<Integer> lazy = () -> name.length();   // fine until get()
    IO.println("lambda created");
    Supplier<Integer> eager = name::length;          // throws right here
    IO.println("method ref created");
}

lambda created
Exception in thread "main" java.lang.NullPointerException

javac literally inserts an Objects.requireNonNull(name) before the invokedynamic, which is why the stack trace points at Objects.requireNonNull and you get no helpful message about which variable was null.

when it's ambiguous

a method reference has to resolve to exactly one method. overloads can make that impossible:

Function<Integer, String> f = Integer::toString;

error: incompatible types: invalid method reference
    reference to toString is ambiguous
      both method toString(int) in Integer and method toString() in Integer match

as a Function<Integer, String>, the Integer argument could be the receiver of toString() (unbound) or the argument to static toString(int). javac refuses to guess. write the lambda (i -> i.toString()), or pick a reference with only one reading, like Object::toString or String::valueOf.

REF_invokeVirtual java/lang/String.length:()I       // String::length
REF_invokeStatic  java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;