Ссылки на методы (method reference) в Java

1. Что такое ссылки на методы

Этот код падает с NullPointerException на второй строке — ещё до того, как кто-либо вызовет supplier.get():

String s = null;
Supplier<Integer> supplier = s::length; // NullPointerException прямо здесь
System.out.println(supplier.get());      // до этой строки дело не дойдёт

Замените ссылку на метод эквивалентной лямбдой () -> s.length() — и исключение переедет на третью строку. Разница в том, когда вычисляется объект слева от ::. С этой детали и начинаются почти все вопросы по теме на собеседованиях.

Ссылка на метод (method reference) — это сокращённая запись лямбда-выражения, которое не делает ничего, кроме вызова одного уже существующего метода. Синтаксис использует оператор :: (двойное двоеточие): слева указывается класс или объект, справа — имя метода без скобок и без аргументов. Ссылки на методы появились в Java 8 вместе с лямбда-выражениями и, как и они, могут присваиваться только функциональному интерфейсу.

Правило простое: если лямбда-выражение вызывает ровно один существующий метод и просто пробрасывает в него свои параметры, лучше сослаться на этот метод по имени. Например:

Consumer<String> consumer = str -> System.out.println(str);

можно переписать с помощью method reference:

Consumer<String> consumer = System.out::println;

Ссылки на методы бывают четырёх видов:

Подсвеченная строка — тот самый вид, который чаще всего сбивает с толку: метод нестатический, а слева от :: стоит имя класса. Разбор в разделе 4.

2. Ссылка на статический метод (ContainingClass::staticMethodName)

Самый прямолинейный вид: слева от :: — имя класса, справа — имя статического метода. Все параметры лямбда-выражения один в один становятся аргументами метода.

Синтаксис:

ContainingClass::staticMethodName

Например:

Function<String, Boolean> function = e -> Boolean.valueOf(e);
System.out.println(function.apply("TRUE")); // true

Перепишем с помощью ссылки на статический метод:

Function<String, Boolean> function = Boolean::valueOf;
System.out.println(function.apply("TRUE")); // true

Количество параметров значения не имеет — лишь бы сигнатура метода подходила функциональному интерфейсу:

Function<String, Integer> parse = Integer::parseInt;        // s -> Integer.parseInt(s)
UnaryOperator<Integer> abs = Math::abs;                      // x -> Math.abs(x)
BiFunction<Integer, Integer, Integer> max = Math::max;       // (a, b) -> Math.max(a, b)

System.out.println(parse.apply("42"));       // 42
System.out.println(abs.apply(-7));           // 7
System.out.println(max.apply(3, 9));         // 9

Типичное применение — в Stream API:

List<String> numbers = List.of("10", "20", "30");
int sum = numbers.stream()
                 .mapToInt(Integer::parseInt)
                 .sum();
System.out.println(sum); // 60

3. Ссылка на нестатический метод конкретного объекта

Синтаксис:

containingObject::instanceMethodName

Этот тип (в англоязычной литературе — bound receiver, «связанный получатель») используется, когда лямбда-выражение вызывает метод внешнего уже существующего объекта. Объект-получатель зафиксирован в самой ссылке, а параметры функционального интерфейса становятся аргументами метода.

Например:

Consumer<String> consumer = e -> System.out.println(e);
consumer.accept("OCPJP 8");

Перепишем, используя ссылку:

Consumer<String> consumer = System.out::println;
consumer.accept("OCPJP 8");

Ещё один пример:

Integer integer = 5;
Supplier<String> supplier = () -> integer.toString();
System.out.println(supplier.get()); // 5

Перепишем:

Integer integer = 5;
Supplier<String> supplier = integer::toString;
System.out.println(supplier.get()); // 5

Получателем может быть и текущий объект — тогда используются this:: и super:::

class Printer {
    void print(String text) {
        System.out.println("> " + text);
    }

    Consumer<String> asConsumer() {
        return this::print;   // ссылка на метод текущего объекта
    }
}

4. Ссылка на нестатический метод любого объекта конкретного типа

Синтаксис:

ContainingType::methodName

Здесь слева стоит имя класса, хотя метод нестатический (unbound receiver, «несвязанный получатель»). Работает это так: первый параметр функционального интерфейса становится объектом, на котором вызывается метод, а остальные параметры — его аргументами.

Например:

Function<String, String> function = s -> s.toLowerCase();
System.out.println(function.apply("OCPJP 8")); // ocpjp 8

Перепишем:

Function<String, String> function = String::toLowerCase;
System.out.println(function.apply("OCPJP 8")); // ocpjp 8

Если у метода есть собственные аргументы, они «сдвигаются» на следующие параметры интерфейса:

BiFunction<String, String, Boolean> equals = String::equalsIgnoreCase;
// эквивалентно: (a, b) -> a.equalsIgnoreCase(b)
System.out.println(equals.apply("Java", "JAVA")); // true

Comparator<String> comparator = String::compareToIgnoreCase;
// эквивалентно: (a, b) -> a.compareToIgnoreCase(b)

На практике этот вид ссылок встречается чаще всего — именно он делает код стримов читаемым:

List<String> names = List.of("bob", "alice", "eve");

names.stream()
     .map(String::toUpperCase)   // s -> s.toUpperCase()
     .sorted()
     .forEach(System.out::println);

List<Person> people = getPeople();
people.sort(Comparator.comparing(Person::getName)); // p -> p.getName()

5. Ссылка на конструктор

Синтаксис:

ClassName::new

ClassName не может быть абстрактным классом или интерфейсом — объект такого типа создать нельзя. Компилятор сам подбирает конструктор, подходящий по числу и типам параметров функционального интерфейса.

Например:

Supplier<List<String>> listSupplier = () -> new ArrayList<>();
List<String> list = listSupplier.get();

Перепишем:

Supplier<List<String>> listSupplier = ArrayList::new;
List<String> list = listSupplier.get();

С конструктором, принимающим аргументы:

class Person {
    private final String name;

    Person(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }
}

Function<String, Person> creator = Person::new;   // name -> new Person(name)
Person person = creator.apply("Alice");
System.out.println(person.getName());             // Alice

Отдельная форма ссылки на конструктор — создание массива: Type[]::new. Она нужна, например, в Stream.toArray():

IntFunction<String[]> arrayCreator = String[]::new;   // size -> new String[size]
String[] empty = arrayCreator.apply(3);

String[] result = Stream.of("a", "b", "c")
                        .toArray(String[]::new);
System.out.println(result.length);  // 3

Ссылки на конструкторы часто используются как «фабрики» в коллекторах:

Set<String> set = Stream.of("a", "b", "a")
                        .collect(Collectors.toCollection(TreeSet::new));
System.out.println(set); // [a, b]

6. Ссылка на метод или лямбда-выражение: что выбрать

Ссылка на метод не быстрее и не «мощнее» лямбда-выражения — это синтаксический сахар. На уровне байт-кода оба варианта компилируются в invokedynamic с использованием LambdaMetafactory. Разница только в читаемости и в паре нюансов поведения.

Практическое правило: пишите ссылку на метод, если лямбда-выражение выглядит как x -> что-то(x) или x -> x.что-то(). Как только внутри появляется хоть что-то ещё — оставайтесь на лямбде.

7. На чём чаще всего спотыкаются

Получатель вычисляется заранее

Уже разобрано выше, но это ошибка номер один. obj::method вычисляет obj немедленно — и падает с NullPointerException в строке объявления, если объект равен null.

Неоднозначная ссылка: reference to ... is ambiguous

Если в классе есть и статический, и нестатический метод с одинаковым именем, и оба подходят по сигнатуре, код не скомпилируется:

class Foo {
    static String bar(Foo f) { return "static"; }
    String bar()             { return "instance"; }
}

Function<Foo, String> f = Foo::bar; // ошибка компиляции: reference to bar is ambiguous

Компилятор не может выбрать между «статический метод с аргументом Foo» и «нестатический метод, вызванный на объекте Foo». Лечится переходом на лямбду с явным вызовом.

Нельзя подставить свой аргумент

Метод-ссылка передаёт параметры интерфейса как есть. Всё, где нужна константа или изменённый порядок, ссылкой не записывается:

Function<String, String> ok   = String::trim;          // корректно
Function<String, String> fail = String::substring;     // не скомпилируется: не хватает аргумента
Function<String, String> okLambda = s -> s.substring(1); // так и оставляем

Перегруженные методы разрешаются по целевому типу

String::valueOf сам по себе неоднозначен — перегрузок больше десятка. Компилятор выбирает нужную по типу переменной, которой присваивается ссылка:

Function<Integer, String> fromInt  = String::valueOf;  // valueOf(int)
Function<char[], String>  fromChars = String::valueOf; // valueOf(char[])

Если целевой тип не позволяет выбрать единственный вариант, будет ошибка компиляции — помогает явное приведение или лямбда.

Ссылка на метод не «замораживает» значение переменной сама по себе

Как и лямбда-выражение, ссылка на метод может захватывать только effectively final переменные. Попытка изменить локальную переменную после создания ссылки на её метод не скомпилируется.