Для чего нужна лямбда функция?

# Лямбда-функции в Java

Определение

Лямбда-функция (Lambda Expression) — это синтаксис для создания анонимных функций (Java 8+). Это компактный способ представить функцию как объект первого класса. Лямбда позволяет передавать поведение как параметр без необходимости создавать отдельный класс.

Синтаксис

// Базовая структура
(параметры) -> тело

// Примеры
() -> System.out.println("Hello")  // Без параметров
(x) -> x * 2                       // Один параметр
x -> x * 2                         // Скобки опционаны для одного параметра
(x, y) -> x + y                    // Несколько параметров
(x, y) -> {                        // Многострочное тело
    int result = x + y;
    return result;
}

Для чего нужны лямбда-функции

1. Функциональное программирование

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

// Без лямбда (старый способ)
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> doubled = new ArrayList<>();
for (Integer n : numbers) {
    doubled.add(n * 2);
}
System.out.println(doubled);  // [2, 4, 6, 8, 10]

// С лямбда (функциональный стиль)
List<Integer> doubled = numbers.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList());
System.out.println(doubled);  // [2, 4, 6, 8, 10]

2. Сокращение boilerplate кода

Вместо создания анонимных классов:

// Без лямбда
button.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        System.out.println("Button clicked");
    }
});

// С лямбда
button.setOnClickListener(v -> System.out.println("Button clicked"));

3. Работа с Collections

Упрощает фильтрацию, маппирование, сортировку:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// Фильтр
List<String> longNames = names.stream()
    .filter(name -> name.length() > 3)
    .collect(Collectors.toList());
// [Alice, Charlie]

// Маппирование
List<Integer> lengths = names.stream()
    .map(name -> name.length())
    .collect(Collectors.toList());
// [5, 3, 7]

// Сортировка
names.sort((a, b) -> b.length() - a.length());
// [Charlie, Alice, Bob]

// Все вместе
List<Integer> result = names.stream()
    .filter(n -> n.length() > 3)
    .map(String::toUpperCase)
    .peek(System.out::println)  // Side effect
    .collect(Collectors.toList());
// ALICE, CHARLIE

4. Функциональные интерфейсы (Functional Interfaces)

Лямбда работают с интерфейсами, имеющими ровно один абстрактный метод:

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

// Predicate<T> — возвращает boolean
Predicate<Integer> isPositive = x -> x > 0;
boolean result = isPositive.test(5);  // true

// Function<T, R> — преобразует T в R
Function<String, Integer> getLength = s -> s.length();
Integer len = getLength.apply("hello");  // 5

// Consumer<T> — выполняет операцию, ничего не возвращает
Consumer<String> print = s -> System.out.println(s);
print.accept("Hello");  // Hello

// Supplier<T> — ничего не принимает, возвращает T
Supplier<Double> random = () -> Math.random();
Double value = random.get();  // 0.234...

// BiFunction<T, U, R> — принимает 2 параметра
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
Integer sum = add.apply(5, 3);  // 8

5. Паттерны проектирования

Лямбда делают некоторые паттерны проще:

// Strategy паттерн
public class PaymentProcessor {
    private Function<Double, Boolean> strategy;
    
    public PaymentProcessor(Function<Double, Boolean> strategy) {
        this.strategy = strategy;
    }
    
    public void process(double amount) {
        if (strategy.apply(amount)) {
            System.out.println("Платеж одобрен");
        }
    }
}

// Использование
PaymentProcessor processor = new PaymentProcessor(
    amount -> amount <= 1000  // Strategy как лямбда
);
processor.process(500);  // Платеж одобрен

// Builder паттерн
List<String> names = new ArrayList<>();
new ArrayList<String>() {{
    add("Alice");
    add("Bob");
}};

// Луче с функциональным стилем
List<String> names = Stream.of("Alice", "Bob")
    .collect(Collectors.toList());

Примеры использования

Пример 1: Фильтрация и маппирование

List<User> users = Arrays.asList(
    new User(1, "Alice", 25),
    new User(2, "Bob", 30),
    new User(3, "Charlie", 20)
);

// Найти всех пользователей старше 21 года и получить их имена
List<String> result = users.stream()
    .filter(user -> user.getAge() > 21)
    .map(User::getName)  // Методная ссылка (тоже лямбда)
    .collect(Collectors.toList());
// [Alice, Bob]

Пример 2: Параллельная обработка

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Обработка в несколько потоков
List<Integer> squared = numbers.parallelStream()
    .map(n -> n * n)
    .collect(Collectors.toList());
// [1, 4, 9, 16, 25]

Пример 3: Группировка

List<String> words = Arrays.asList("apple", "apricot", "banana", "blueberry");

Map<Character, List<String>> grouped = words.stream()
    .collect(Collectors.groupingBy(word -> word.charAt(0)));
// {a=[apple, apricot], b=[banana, blueberry]}

Пример 4: Параметризованная логика

public static <T> void processElements(
    List<T> list,
    Consumer<T> processor) {
    list.forEach(processor);
}

// Использование
List<String> names = Arrays.asList("Alice", "Bob");
processElements(names, System.out::println);
// Alice
// Bob

Методные ссылки (Method References)

Лямбда часто можно заменить методной ссылкой для читаемости:

// Лямбда
list.forEach(x -> System.out.println(x));
// Методная ссылка
list.forEach(System.out::println);

// Лямбда
users.stream().map(user -> user.getName())
// Методная ссылка
users.stream().map(User::getName)

// Лямбда
integers.stream().map(Integer::valueOf)
// Это тоже методная ссылка (конструктор)
numbers.stream().map(String::new)

Плюсы лямбда-функций

1. Меньше кода — вместо 5 строк для анонимного класса, 1 строка
2. Читаемость — намерение кода ясно
3. Функциональный стиль — чистая функция без побочных эффектов
4. Stream API — невозможно без лямбда
5. Параллелизм — parallelStream() удобнее использовать с лямбда
6. Тестируемость — проще передавать поведение для тестирования

Минусы / Ограничения

1. Только для функциональных интерфейсов — не работает с обычными интерфейсами
2. Сложность отладки — stack trace менее информативен
3. Переусложнение — цепочки stream() могут быть нечитаемы
4. Производительность — stream() медленнее цикла for (но проще)

Когда использовать

✓ Фильтрация, маппирование коллекций ✓ Передача поведения как параметра ✓ Работа с Collections.sort(), stream API ✓ Event listeners, callbacks ✓ Strategy паттерн

✗ Сложная многострочная логика (используй обычный метод) ✗ Рекурсия ✗ Когда нужен stack trace

Вывод

Лямбда-функции — это не просто синтаксический сахар. Это изменило парадигму Java разработки, позволив использовать функциональное программирование наравне с ООП. Stream API и лямбда-функции — обязательные навыки для современного Java разработчика.