Как лямбда взаимодействует с функциональным интерфейсом

Взаимодействие лямбда-выражений с функциональными интерфейсами

Это основной механизм, введённый в Java 8. Лямбда-выражения и функциональные интерфейсы — две стороны одной монеты.

Что такое функциональный интерфейс?

Функциональный интерфейс — это интерфейс с ровно одним абстрактным методом. Это критическое ограничение:

// ПРАВИЛЬНО: функциональный интерфейс
@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);  // один абстрактный метод
}

// НЕПРАВИЛЬНО: два абстрактных метода
@FunctionalInterface  // Ошибка компиляции!
public interface BadInterface {
    void method1();
    void method2();
}

// ПРАВИЛЬНО: может быть несколько методов по умолчанию
@FunctionalInterface
public interface GoodInterface {
    void abstractMethod();
    
    default void defaultMethod() {
        System.out.println("default");
    }
    
    static void staticMethod() {
        System.out.println("static");
    }
}

Аннотация @FunctionalInterface не обязательна, но рекомендуется для явности.

Как лямбда преобразуется в функциональный интерфейс?

При встрече лямбда-выражения с переменной типа функционального интерфейса компилятор автоматически:

1. Создает анонимный класс с реализацией функционального интерфейса
2. Связывает параметры лямбды с параметрами абстрактного метода
3. Связывает тело лямбды с телом абстрактного метода

public interface MyOperation {
    int execute(int x, int y);
}

public class LambdaExample {
    public static void main(String[] args) {
        // Лямбда-выражение
        MyOperation add = (a, b) -> a + b;
        
        // Эквивалентно
        MyOperation addLegacy = new MyOperation() {
            @Override
            public int execute(int x, int y) {
                return x + y;
            }
        };
        
        // Обе работают одинаково
        System.out.println(add.execute(5, 3));        // 8
        System.out.println(addLegacy.execute(5, 3));  // 8
    }
}

Инструментарий типизации

Компилятор использует target type для определения, какой интерфейс использовать:

@FunctionalInterface
interface Predicate<T> {
    boolean test(T t);
}

@FunctionalInterface
interface Function<T, R> {
    R apply(T t);
}

public class TargetTypeExample {
    public static void main(String[] args) {
        // ОДИН КОД, РАЗНЫЕ ТИПЫ благодаря target type
        
        Predicate<Integer> isPositive = x -> x > 0;
        // Компилятор понимает: это лямбда для Predicate
        // Параметр x: Integer, возвращаемое значение: boolean
        
        Function<Integer, String> toString = x -> "Number: " + x;
        // Компилятор понимает: это лямбда для Function
        // Параметр x: Integer, возвращаемое значение: String
        
        // Одна лямбда - разные результаты в зависимости от контекста
        Predicate<String> isEmpty = s -> s.length() == 0;
    }
}

Встроенные функциональные интерфейсы Java

Java 8 предоставляет стандартные функциональные интерфейсы в java.util.function:

import java.util.function.*;

public class BuiltInFunctionalInterfaces {
    public static void main(String[] args) {
        // 1. Supplier<T> - производит значение, параметров нет
        Supplier<String> supplier = () -> "Hello";
        System.out.println(supplier.get());  // Hello
        
        // 2. Consumer<T> - потребляет значение, ничего не возвращает
        Consumer<String> consumer = s -> System.out.println(s);
        consumer.accept("Hello");  // Hello
        
        // 3. Function<T, R> - преобразует T в R
        Function<String, Integer> length = s -> s.length();
        System.out.println(length.apply("Hello"));  // 5
        
        // 4. Predicate<T> - проверяет условие
        Predicate<Integer> isEven = x -> x % 2 == 0;
        System.out.println(isEven.test(4));  // true
        
        // 5. UnaryOperator<T> - T -> T (частный случай Function)
        UnaryOperator<Integer> increment = x -> x + 1;
        System.out.println(increment.apply(5));  // 6
        
        // 6. BinaryOperator<T> - (T, T) -> T
        BinaryOperator<Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(3, 4));  // 7
    }
}

Процесс компиляции лямбда-выражений

Когда ты пишешь лямбду, компилятор:

public interface StringProcessor {
    String process(String input);
}

public class CompilationExample {
    public static void main(String[] args) {
        // Исходный код
        StringProcessor toUpper = s -> s.toUpperCase();
        String result = toUpper.process("hello");
        
        // ШАГ 1: Компилятор видит лямбду и target type StringProcessor
        // ШАГ 2: Компилятор создает приватный статический метод:
        // private static String lambda$0(String s) {
        //     return s.toUpperCase();
        // }
        
        // ШАГ 3: Компилятор генерирует invokedynamic байт-код
        // который в runtime создает экземпляр StringProcessor
        
        // ШАГ 4: Runtime выполняет LambdaMetafactory.metafactory()
        // которая создает анонимный класс, реализующий StringProcessor
    }
}

Сложные сигнатуры лямбда

@FunctionalInterface
interface MathOperation {
    int calculate(int a, int b);
}

@FunctionalInterface
interface StringTransform {
    String transform(String s);
}

public class ComplexLambdas {
    public static void main(String[] args) {
        // Короткая форма (одно выражение)
        MathOperation multiply = (a, b) -> a * b;
        
        // Блочная форма (несколько строк)
        MathOperation complexCalc = (a, b) -> {
            int sum = a + b;
            int product = a * b;
            return sum * product;
        };
        
        // Явная типизация параметров
        MathOperation divide = (int a, int b) -> {
            if (b == 0) throw new IllegalArgumentException();
            return a / b;
        };
        
        // Без параметров
        Supplier<Integer> random = () -> (int)(Math.random() * 100);
        
        // Один параметр (скобки опциональны)
        StringTransform reverse1 = s -> new StringBuilder(s).reverse().toString();
        StringTransform reverse2 = (s) -> new StringBuilder(s).reverse().toString();
    }
}

Практический пример: обработка коллекций

import java.util.*;
import java.util.stream.*;

public class CollectionProcessing {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        
        // Использование Predicate в Stream API
        List<Integer> evens = numbers.stream()
            .filter(n -> n % 2 == 0)  // Predicate: int -> boolean
            .collect(Collectors.toList());
        System.out.println(evens);  // [2, 4, 6]
        
        // Использование Function в Stream API
        List<String> strings = numbers.stream()
            .map(n -> "Number: " + n)  // Function: int -> String
            .collect(Collectors.toList());
        System.out.println(strings);  // [Number: 1, Number: 2, ...]
        
        // Использование Consumer в Stream API
        numbers.stream()
            .filter(n -> n % 2 == 0)
            .forEach(n -> System.out.println(n));  // Consumer: int -> void
    }
}

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

public class FunctionComposition {
    public static void main(String[] args) {
        // Создание цепочки функций
        Function<Integer, Integer> addFive = x -> x + 5;
        Function<Integer, Integer> multiplyByTwo = x -> x * 2;
        
        // Композиция: сначала addFive, потом multiplyByTwo
        Function<Integer, Integer> composed = addFive.andThen(multiplyByTwo);
        System.out.println(composed.apply(3));  // (3 + 5) * 2 = 16
        
        // Обратная композиция: сначала multiplyByTwo, потом addFive
        Function<Integer, Integer> composed2 = addFive.compose(multiplyByTwo);
        System.out.println(composed2.apply(3));  // 3 * 2 + 5 = 11
        
        // Чинирование Predicate
        Predicate<Integer> isPositive = x -> x > 0;
        Predicate<Integer> isEven = x -> x % 2 == 0;
        
        Predicate<Integer> isPositiveEven = isPositive.and(isEven);
        System.out.println(isPositiveEven.test(4));   // true
        System.out.println(isPositiveEven.test(-4));  // false
    }
}

Чем отличается от анонимных классов

// Анонимный класс (Java 7 и ранее)
Calculator calc1 = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// Лямбда-выражение (Java 8+)
Calculator calc2 = (a, b) -> a + b;

// Преимущества лямбды:
// 1. Короче и читаема
// 2. Меньше памяти (invokedynamic более эффективен)
// 3. Лучше интегрируется со Stream API
// 4. Удобнее для функционального программирования

Заключение

Взаимодействие лямбды и функционального интерфейса:

1. Определяешь функциональный интерфейс с одним методом
2. Пишешь лямбду, соответствующую сигнатуре этого метода
3. Компилятор использует target type для определения типа
4. Runtime создает экземпляр через LambdaMetafactory
5. Результат — чистое, функциональное код на Java

Это мощная абстракция, которая позволяет писать функциональный код в Java с типизацией.