Лямбда-выражения в Java: лаконичный функциональный код

Поведение, которое можно передавать

Лямбда-выражение — это компактный блок кода, который можно передать в метод, сохранить в переменной или вернуть, точно так же, как число или строку. До появления лямбд передача поведения означала написание целого класса (или многословного анонимного класса) только ради того, чтобы обернуть один метод. Лямбда сводит это к сути: к параметрам и телу.

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

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;       // реализует apply(int)
        Transformer square  = x -> x * x;

        System.out.println(doubler.apply(21));  // 42
        System.out.println(square.apply(9));     // 81
    }
}

x -> x * 2 — это полная реализация apply. Никакого new, никакого тела класса, никакого имени метода — всё это берёт на себя интерфейс.

Синтаксис со стрелкой

Любая лямбда имеет форму параметры -> тело. Части гибко меняются в зависимости от того, что вам нужно:

() -> 42                       // без параметров
x -> x + 1                     // один параметр, скобки необязательны
(x, y) -> x + y                // два и более параметра требуют скобок
(int x, int y) -> x + y        // типы необязательны - обычно выводятся
x -> {                          // блочное тело требует фигурных скобок и return
    int doubled = x * 2;
    return doubled + 1;
}

Тело из одного выражения (x -> x + 1) неявно возвращает своё значение — без ключевого слова return. Как только вы используете фигурные скобки, вы пишете обычный блок и обязаны указывать return явно, если метод что-то возвращает. Частая ошибка — смешивать эти два варианта: x -> { x + 1 } не компилируется, потому что блоку нужна инструкция (return x + 1;).

Лямбды заменяют анонимные классы

Нагляднее всего польза от лямбды видна в сравнении «до и после». Сортировка с собственным Comparator раньше выглядела так:

// до - анонимный класс
names.sort(new Comparator<String>() {
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
});

То же самое в виде лямбды — это одна читаемая строка:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Charlie", "Bo", "Alex"));

        names.sort((a, b) -> a.length() - b.length());   // после - лямбда

        System.out.println(names);   // [Bo, Alex, Charlie]
    }
}

Comparator — это функциональный интерфейс (его единственный абстрактный метод — compare), поэтому лямбда подставляется напрямую. Все церемонии — new, класс, сигнатура метода — исчезают, оставляя лишь логику сравнения.

Набор инструментов java.util.function

Объявлять собственный функциональный интерфейс приходится редко. Пакет java.util.function содержит распространённые формы, и почти все библиотечные API Java их принимают:

• Function<T, R> — принимает T, возвращает R (apply)
• Predicate<T> — принимает T, возвращает boolean (test)
• Supplier<T> — ничего не принимает, возвращает T (get)
• Consumer<T> — принимает T, ничего не возвращает (accept)

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

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = s -> s.length();
        Predicate<Integer> isEven        = n -> n % 2 == 0;
        Supplier<String> greeting        = () -> "hello";

        System.out.println(length.apply("lambda"));   // 6
        System.out.println(isEven.test(10));           // true
        System.out.println(greeting.get());            // hello
    }
}

Это обобщённые (generic) интерфейсы: Function<String, Integer> повторно использует дженерики, которые вы видели на предыдущей странице, чтобы оставаться типобезопасным. Выбирайте тот, чья форма соответствует тому, что вашему коду нужно принимать и производить.

Ссылки на методы

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

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("pear", "fig", "apple", "kiwi"));

        // лямбда:           s -> s.toUpperCase()
        // ссылка на метод: String::toUpperCase
        words.replaceAll(String::toUpperCase);
        System.out.println(words);   // [PEAR, FIG, APPLE, KIWI]

        // сортировка по длине с использованием статического метода как Comparator
        words.sort((a, b) -> Integer.compare(a.length(), b.length()));
        System.out.println(words);   // [FIG, PEAR, KIWI, APPLE]
    }
}

Ссылки на методы бывают разных видов: String::toUpperCase (метод экземпляра, вызываемый на каждом аргументе), Math::max (статический метод), System.out::println (метод конкретного объекта) и ArrayList::new (конструктор). Прибегайте к ним только тогда, когда они читаются ясно: если приходится задумываться, какая форма применяется, обычная лямбда вполне подойдёт.

Захват переменных

Лямбда может использовать локальные переменные окружающего метода, но только если они final или фактически final — присвоены один раз и больше не изменяются. Java захватывает значение в момент создания лямбды, поэтому переменная, которая могла бы измениться позже, была бы неоднозначной.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        int factor = 3;                          // не переприсваивается -> фактически final
        Function<Integer, Integer> scale = n -> n * factor;

        System.out.println(scale.apply(10));     // 30
        // factor = 4;   // <- если раскомментировать, лямбда выше перестанет работать
    }
}

Если вы переприсвоите factor где-либо, компилятор отклонит лямбду с сообщением «variable used in lambda expression should be final or effectively final». Когда вам действительно нужно изменяемое разделяемое состояние, захватывайте вместо этого объект — поле, элемент массива или AtomicInteger, — потому что ссылка остаётся неизменной, даже если её содержимое меняется. Обратите внимание: лямбды, в отличие от анонимных классов, не создают собственную область видимости: this внутри лямбды ссылается на охватывающий экземпляр, а не на саму лямбду.

Далее: Streams

Лямбды — это строительный блок, а не конечная цель. Их настоящая отдача проявляется с API Streams, где вы выстраиваете цепочки операций вроде filter, map и reduce — каждая принимает лямбду, — чтобы выразить преобразования данных как читаемый конвейер вместо клубка циклов. Это тема следующей страницы.