Method references as shorthand for lambdas

Understanding Method references as shorthand for lambdas

The :: operator names a method without calling it. The compiler looks at the functional interface the expression is being assigned to, takes that interface's single abstract method, and generates an implementation whose entire body is a call to the method you named. Because the meaning depends completely on that target type, a method reference has no type of its own: var f = String::toUpperCase; does not compile, while Function<String, String> f = String::toUpperCase; does.

To read any method reference, ask where the receiver, the object the method runs on, comes from. Integer::parseInt has none, so every interface parameter becomes an argument; System.out::println fixes the receiver on the left and still passes the parameters as arguments. String::toUpperCase takes the receiver from the first parameter and shifts the rest down, which is why String::startsWith can implement a two-parameter BiPredicate even though startsWith declares one parameter. Tag::new is the same alignment with a constructor, and Tag[]::new takes an int length and hands back a new array.

That alignment is resolved at compile time from the target type, which is why identical text can mean different things in different places, and why Integer::toString is rejected as ambiguous for Function<Integer, String>: the static toString(int) and the instance toString() both fit. The bound form has one more consequence: the expression left of :: is evaluated once, exactly where the reference is created, so list::size snapshots which object you will ask, not what its size is. The shorthand reaches only as far as one call with arguments in their declared order, no reordering, no negation, no second step, so s -> s.trim().length() stays a lambda.

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

public class MethodRefs {
    public static void main(String[] args) {
        // static method: no receiver, every parameter is an argument
        Function<String, Integer> parse = Integer::parseInt;

        // bound instance method: the receiver is fixed by the left side
        String greeting = "Method references";
        Supplier<Integer> length = greeting::length;

        // unbound instance method: the first parameter becomes the receiver
        Function<String, String> upper = String::toUpperCase;
        BiFunction<String, String, Boolean> startsWith = String::startsWith;

        // constructor reference
        Function<String, StringBuilder> build = StringBuilder::new;

        System.out.println(parse.apply("42") + 1);
        System.out.println(length.get());
        System.out.println(upper.apply("shorthand"));
        System.out.println(startsWith.apply("shorthand", "short"));
        System.out.println(build.apply("abc").reverse());

        List.of("io", "nio").forEach(System.out::println);
    }
}

Worked examples

import java.util.function.Supplier;

public class BoundReceiver {
    static int calls = 0;

    static StringBuilder makeBuffer() {
        calls++;
        return new StringBuilder("buf" + calls);
    }

    public static void main(String[] args) {
        Supplier<String> viaRef = makeBuffer()::toString;
        Supplier<String> viaLambda = () -> makeBuffer().toString();

        System.out.println("calls after creating both: " + calls);
        System.out.println(viaRef.get() + " " + viaRef.get());
        System.out.println(viaLambda.get() + " " + viaLambda.get());
        System.out.println("calls at the end: " + calls);
    }
}

import java.util.function.BiPredicate;
import java.util.function.Predicate;

public class ReceiverPosition {
    public static void main(String[] args) {
        BiPredicate<String, String> starts = String::startsWith;
        System.out.println(starts.test("codec", "co"));

        String fixed = "codec";
        Predicate<String> codecStartsWith = fixed::startsWith;
        System.out.println(codecStartsWith.test("co"));
        System.out.println(codecStartsWith.test("codec is longer"));

        Predicate<String> startsWithCo = s -> s.startsWith("co");
        System.out.println(startsWithCo.test("codec is longer"));
    }
}

import java.util.Arrays;
import java.util.stream.Stream;

public class ConstructorRefs {
    record Tag(String name) {}

    public static void main(String[] args) {
        Tag[] tags = Stream.of("java", "streams")
                           .map(Tag::new)
                           .toArray(Tag[]::new);

        System.out.println(Arrays.toString(tags));
        System.out.println(tags.length + " " + tags.getClass().getSimpleName());
    }
}

Important notes

Common mistakes

Try it yourself