How Do Method References Work?

Method references are shorthand for lambdas that call an existing method. You write the method name, two colons, and optionally the receiver or the type. There are exactly four forms, and each maps onto a different functional interface shape.

Static method reference — Integer::parseInt. The receiver is the class, and the functional interface's argument becomes the method's argument.

Bound instance method reference — "hello"::toUpperCase. The receiver is a fixed object, and the functional interface takes no arguments, because the receiver already supplies them. This is the form that lets you use a Supplier when you have one object.

Unbound instance method reference — String::length. The functional interface's first argument becomes the receiver, and the remaining arguments are passed to the method. A Function<String, Integer> matches length, because the String is the receiver and the method needs nothing else.

Constructor reference — ArrayList::new. It calls a constructor, and the functional interface's arguments are the constructor's arguments. A Supplier can use the no-argument constructor, or a Function<Integer, ArrayList> can use the one that takes a capacity.

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

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

        // 2. Instance method of a bound object.
        Supplier<String> upper = "hello"::toUpperCase;
        System.out.println("bound      : " + upper.get());

        // 3. Instance method where the receiver is the first argument.
        Function<String, Integer> length = String::length;
        System.out.println("unbound    : " + length.apply("tutorsbot"));

        // 4. Constructor reference.
        Function<Integer, java.util.ArrayList<String>> list = java.util.ArrayList::new;
        System.out.println("constructor: " + list.apply(3).size());

        // A two-argument static method.
        BiFunction<String, String, Boolean> eq = String::equalsIgnoreCase;
        System.out.println("bi         : " + eq.apply("JAVA", "java"));
    }
}

The output shows each form doing exactly what the theory predicts. The static reference parses a string into an integer. The bound reference uppercases a fixed string with no argument. The unbound reference measures whichever string it is handed. The constructor reference builds a list with the capacity it is given.

Use a method reference when the lambda does nothing but call an existing method with the same arguments. In that case the reference is shorter and states the intent more directly — list.forEach(System.out::println) says "print each one", whereas list.forEach(s -> System.out.println(s)) says the same thing more slowly.

Use a lambda as soon as there is any logic in the body. If the lambda filters, transforms, combines two values or introduces a new variable, the method reference form cannot express it and the lambda is the only option — list.removeIf(s -> s.length() > 3) has no reference equivalent because there is no existing method that does exactly that.

Two more cases where the choice matters. When you need to override an inherited method, a method reference cannot be used — the compiler picks the implementation from the receiver's type, so you need a lambda to call super or to branch. And when the method reference would be ambiguous, such as String::valueOf where several overloads exist, the compiler may not be able to choose, and a lambda with an explicit cast resolves it.

A useful test: read the line out loud. If it sounds like "call this method", use a reference. If it sounds like "compute this", use a lambda. And in a code review, the difference matters less than consistency — pick one style per codebase, because mixing them makes a file feel noisier than it needs to be.