Method References

A method reference is shorthand notation for a lambda expression that does nothing but call an existing method. Instead of writing x -> ClassName.method(x), you can write ClassName::method, using the double-colon :: operator. Method references are purely syntactic sugar — they compile down to the same functional interface implementation a lambda would produce.

Why it matters

Method references are the shortest way to pass an existing method where a lambda is expected, and stream code is full of them: String::toUpperCase, System.out::println, ArrayList::new. You need to be able to read them at a glance and to know which of the four forms you are looking at.

The Four Kinds of Method References

Java recognizes four distinct forms, each matching a different lambda shape:

• Static method reference — ClassName::staticMethod, equivalent to args -> ClassName.staticMethod(args). Example: Integer::parseInt.
• Instance method reference on a particular object — instance::method, equivalent to args -> instance.method(args). Example: System.out::println.
• Instance method reference on an arbitrary object of a type — ClassName::instanceMethod, equivalent to (obj, args) -> obj.instanceMethod(args), where the first lambda parameter becomes the object the method is called on. Example: String::toUpperCase.
• Constructor reference — ClassName::new, equivalent to args -> new ClassName(args). Example: ArrayList::new.

Choosing Between a Lambda and a Method Reference

A method reference is preferred when the lambda body would do nothing except forward its arguments to an existing method, because it is shorter and more directly communicates intent. If any extra logic, transformation, or multiple statements are needed, a plain lambda is the better and often only option.

Example

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

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

        // 2. Instance method reference on a particular object
        List<String> items = Arrays.asList("pen", "book");
        items.forEach(System.out::println);

        // 3. Instance method reference on an arbitrary object of a type
        Function<String, String> upper = String::toUpperCase;
        System.out.println(upper.apply("java"));

        // 4. Constructor reference
        Supplier<StringBuilder> builderFactory = StringBuilder::new;
        StringBuilder sb = builderFactory.get();
        sb.append("built via constructor reference");
        System.out.println(sb);
    }
}

42
pen
book
JAVA
built via constructor reference

Exercise

Replace both lambdas with method references. The output must not change.

Expected output: ASHA then RAVI

import java.util.List;

public class UseMethodReferences {
    public static void main(String[] args) {
        List<String> names = List.of("asha", "ravi");

        names.stream()
                .map(name -> name.toUpperCase())          // TODO: method reference
                .forEach(name -> System.out.println(name)); // TODO: method reference
    }
}

import java.util.List;

public class UseMethodReferences {
    public static void main(String[] args) {
        List<String> names = List.of("asha", "ravi");

        names.stream()
                .map(String::toUpperCase)
                .forEach(System.out::println); // ASHA, RAVI
    }
}

Quick quiz

Interview questions