Специализации функциональных интерфейсов в Java

Этот цикл выглядит безобидно, но за десять миллионов итераций он создаёт десять миллионов лишних объектов:

Function<Integer, Integer> square = x -> x * x;

long sum = 0;
for (int i = 0; i < 10_000_000; i++) {
    sum += square.apply(i);   // int -> Integer -> int на каждом шаге
}

Метод apply объявлен как R apply(T t) и умеет работать только с объектами, поэтому каждый int сначала упаковывается в Integer, а затем тут же распаковывается обратно. Достаточно заменить тип переменной на IntUnaryOperator с методом int applyAsInt(int) — и упаковка исчезает полностью. Именно ради таких случаев в JDK существуют специализации функциональных интерфейсов.

Специализации функциональных интерфейсов (functional interface specializations) — это варианты базовых интерфейсов пакета java.util.function, рассчитанные на другое количество аргументов (бинарные специализации) или на примитивные типы int, long, double вместо объектов (примитивные специализации). Всего пакет java.util.function содержит 43 интерфейса: 9 обобщённых (объектных) и 34 примитивных.

Зачем нужны специализации: цена автоупаковки

Дженерики в Java не работают с примитивными типами: запись Function<int, int> не компилируется. Поэтому любой обобщённый функциональный интерфейс — Predicate, Consumer, Function, Supplier — вынужден принимать и возвращать объекты. Когда в него передают число, включается автоупаковка (autoboxing), а на выходе — автораспаковка (unboxing).

Что это стоит на практике:

• каждый упакованный int — отдельный объект в куче (в 64-битной HotSpot это порядка 16 байт плюс 4–8 байт на ссылку против 4 байт у примитива);
• миллионы короткоживущих Integer нагружают сборщик мусора;
• массив ссылок на Integer раскидан по куче, тогда как int[] лежит одним непрерывным блоком — теряется локальность данных и эффективность кеша процессора.

Примитивные специализации решают проблему на уровне сигнатуры: их абстрактные методы объявлены сразу над примитивами.

// Упаковка на каждом вызове
Function<Integer, Integer> squareBoxed = x -> x * x;

// Ни одной упаковки: int на входе, int на выходе
IntUnaryOperator square = x -> x * x;

int sum = IntStream.rangeClosed(1, 100)
                   .map(square)   // IntUnaryOperator
                   .sum();        // 338350

Бинарные специализации функциональных интерфейсов

Базовые интерфейсы Predicate<T>, Consumer<T> и Function<T, R> принимают один аргумент. Для двух аргументов в java.util.function есть бинарные специализации (binary specializations) с приставкой Bi-. Бинарным аналогом UnaryOperator выступает BinaryOperator.

BiFunction<String, Integer, String> repeat = (s, n) -> s.repeat(n);
System.out.println(repeat.apply("ab", 3));        // ababab

BiPredicate<String, Integer> isLonger = (s, n) -> s.length() > n;
System.out.println(isLonger.test("Java", 3));     // true

BiConsumer<String, Integer> printer = (k, v) -> System.out.println(k + " = " + v);
printer.accept("age", 30);                        // age = 30

BinaryOperator<Integer> max = BinaryOperator.maxBy(Comparator.naturalOrder());
System.out.println(max.apply(7, 42));             // 42

Метод String.repeat() доступен начиная с Java 11. Интерфейсов на три и более аргумента (TriFunction и подобных) в стандартной библиотеке нет — при необходимости их объявляют самостоятельно.

Примитивные специализации функциональных интерфейсов

Примитивные специализации существуют для трёх типов: int, long и double (плюс BooleanSupplier для boolean). Ниже — полный список по группам.

Специализации Predicate

Как и Predicate<T>, эти интерфейсы имеют default-методы and(), or() и negate() для комбинирования условий.

Специализации Consumer

Специализации Function

У Function<T, R> примитивным может быть вход, выход или и то и другое — отсюда три подгруппы.

Принимающие примитив, возвращающие объект

Принимающие объект, возвращающие примитив

Принимающие и возвращающие примитив

Пар IntToIntFunction или DoubleToDoubleFunction в JDK нет — их роль выполняют IntUnaryOperator и DoubleUnaryOperator.

Специализации Supplier

Обратите внимание: у Supplier<T> метод называется get(), а у примитивных версий — getAsInt(), getAsLong(), getAsDouble(), getAsBoolean(). Разные имена нужны, чтобы избежать конфликта стирания типов.

Специализации UnaryOperator

Специализации BinaryOperator

Специализации BiConsumer

Порядок аргументов фиксирован: сначала объект, затем примитив. Такая сигнатура удобна для аккумуляторов — например, в трёхаргументном IntStream.collect().

ObjIntConsumer<StringBuilder> append = StringBuilder::append;

StringBuilder sb = new StringBuilder("x=");
append.accept(sb, 42);
System.out.println(sb);   // x=42

Специализации BiFunction

Симметричных IntBiFunction или BiPredicate над примитивами в JDK нет: два примитивных аргумента покрывают только IntBinaryOperator и его аналоги.

Как расшифровать имя интерфейса по его названию

Имена в java.util.function строятся по строгому шаблону, и, зная его, сигнатуру любого из 43 интерфейсов можно восстановить по названию.

Имя абстрактного метода тоже подчиняется правилу: если результат примитивный, к глаголу добавляется суффикс As + тип — applyAsInt, applyAsLong, applyAsDouble, getAsInt, getAsBoolean. У методов test и accept суффикса нет: их возвращаемый тип (boolean и void) и так фиксирован.

Где специализации встречаются в Stream API

Чаще всего эти интерфейсы попадаются не в объявлениях переменных, а в сигнатурах методов Stream, IntStream, Map и List. Таблица ниже помогает понять, какую лямбду от вас ждёт компилятор.

List<String> words = List.of("Java", "Stream", "API");

// ToIntFunction<String>: объект -> примитив
int totalLength = words.stream()
                       .mapToInt(String::length)
                       .sum();                       // 13

// IntPredicate: фильтрация без упаковки
long evenCount = IntStream.rangeClosed(1, 10)
                          .filter(n -> n % 2 == 0)
                          .count();                  // 5

// IntBinaryOperator: свёртка
int factorial = IntStream.rangeClosed(1, 5)
                         .reduce(1, (a, b) -> a * b); // 120

// IntFunction<String>: примитив -> объект
List<String> labels = IntStream.rangeClosed(1, 3)
                               .mapToObj(n -> "#" + n)
                               .toList();             // [#1, #2, #3]

Где чаще всего спотыкаются

• Примитивные интерфейсы не наследуют обобщённые. IntBinaryOperator не является наследником BiFunction, а IntPredicate — наследником Predicate. Это независимые типы, и переменную одного нельзя присвоить переменной другого.
• У IntFunction, ToIntFunction и ToIntBiFunction нет default-методов. Привычные andThen() и compose() есть у Function, IntUnaryOperator и DoubleUnaryOperator, но не у «смешанных» специализаций — цепочку придётся собирать лямбдой вручную.
• Специализаций для float, byte, short и char не существует. Для них используют int- и double-версии, полагаясь на расширяющее преобразование.
• UnaryOperator<T> и Function<T, T> взаимозаменяемы не в обе стороны. UnaryOperator<String> можно передать туда, где ждут Function<String, String>, но не наоборот: UnaryOperator наследует Function, а не равен ему.
• Забытый boxed(). Чтобы из IntStream получить Stream<Integer> и собрать его в List<Integer>, нужен вызов boxed() либо mapToObj().