What is a method reference, and what are its forms?

A method reference is compact syntax for a lambda whose entire body is just calling one existing method — the compiler infers the parameter list from the target functional interface, so you don't need to spell it out.

There are four forms:

1. Static method reference — Type::staticMethod:

Function<String, Integer> parse = Integer::parseInt;
// equivalent to: s -> Integer.parseInt(s)

2. Bound instance method reference — instance::method (the receiver object is already fixed):

String prefix = "Hello, ";
Function<String, String> greet = prefix::concat;
// equivalent to: s -> prefix.concat(s)

3. Unbound instance method reference — Type::instanceMethod (no specific instance yet — the first lambda parameter becomes the receiver, remaining parameters are passed to the method):

Function<String, Integer> length = String::length;
// equivalent to: s -> s.length()

BiFunction<String, String, Boolean> startsWith = String::startsWith;
// equivalent to: (s, prefix) -> s.startsWith(prefix)

4. Constructor reference — Type::new:

Supplier<ArrayList<String>> factory = ArrayList::new;
// equivalent to: () -> new ArrayList<>()

Function<String, StringBuilder> toBuilder = StringBuilder::new;
// equivalent to: s -> new StringBuilder(s)

Method references are purely syntactic sugar over an equivalent lambda — they compile to the same kind of invokedynamic-based construct — and are generally preferred over an explicit lambda when the lambda would do nothing but forward its arguments to an existing method, since they read more directly as "call this method" rather than restating the parameter list.