Используешь ли лямбда-выражения

# Использование лямбда-выражений в Java

Краткий ответ

Да, широко использую. Lambda-выражения - это один из самых важных инструментов современной Java (с версии 8), которые делают код более компактным, читаемым и функциональным. Они неотъемлемая часть работы со Stream API и функциональным программированием.

Что такое лямбда-выражение

Лямбда - это анонимная функция, которая позволяет передавать блоки кода как значения.

Синтаксис

// Базовый синтаксис: (параметры) -> { тело }

// 1. Одноопера без параметров
() -> System.out.println("Hello");

// 2. Один параметр
x -> x * 2

// 3. Несколько параметров
(x, y) -> x + y

// 4. С фигурными скобками
(x, y) -> {
    int result = x + y;
    return result;
}

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

1. Работа со Stream API

// Фильтрация
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

// Преобразование
List<String> names = users.stream()
    .map(user -> user.getName().toUpperCase())
    .collect(Collectors.toList());

// Сортировка
List<User> sortedByAge = users.stream()
    .sorted((u1, u2) -> Integer.compare(u1.getAge(), u2.getAge()))
    .collect(Collectors.toList());

// forEach
users.forEach(user -> System.out.println(user.getName()));

2. Callbacks и обработчики событий

// Без лямбды (Java 7)
button.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        handleButtonClick();
    }
});

// С лямбдой (Java 8+)
button.setOnClickListener(v -> handleButtonClick());

3. Потоки (Threads)

// Без лямбды
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Running in thread");
    }
}).start();

// С лямбдой
new Thread(() -> System.out.println("Running in thread")).start();

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

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

// Использование с разными лямбдами
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;
Calculator divide = (a, b) -> a / b;

System.out.println(add.calculate(10, 5));        // 15
System.out.println(multiply.calculate(10, 5));   // 50
System.out.println(divide.calculate(10, 5));     // 2

5. Optional и Stream chains

// Поиск в потоке с обработкой результата
users.stream()
    .filter(u -> u.isActive())
    .findFirst()
    .ifPresentOrElse(
        user -> System.out.println("Found: " + user.getName()),
        () -> System.out.println("No active users")
    );

// Преобразование Optional
Optional<String> email = user.getEmail()
    .map(e -> e.toLowerCase())
    .filter(e -> e.endsWith("@company.com"));

6. Комбинирование лямбд

// Создание более сложной логики
Predicate<User> isAdult = user -> user.getAge() >= 18;
Predicate<User> isActive = User::isActive;
Predicate<User> isModerator = user -> "MODERATOR".equals(user.getRole());

// Комбинирование условий
List<User> moderators = users.stream()
    .filter(isAdult.and(isActive).and(isModerator))
    .collect(Collectors.toList());

Функциональные интерфейсы из java.util.function

// Predicate<T> - проверка условия
Predicate<String> isEmpty = s -> s.isEmpty();

// Function<T, R> - преобразование
Function<String, Integer> length = s -> s.length();

// Consumer<T> - выполнение действия без результата
Consumer<String> printer = s -> System.out.println(s);

// Supplier<T> - создание значения без параметров
Supplier<LocalDateTime> currentTime = () -> LocalDateTime.now();

// BiFunction<T, U, R> - функция с двумя параметрами
BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b;

// UnaryOperator<T> - функция с одним параметром (вход = выход)
UnaryOperator<Integer> square = x -> x * x;

// BinaryOperator<T> - функция с двумя параметрами (все одного типа)
BinaryOperator<Integer> max = (a, b) -> a > b ? a : b;

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

Лямбды можно еще больше упростить через ссылки на методы:

// Вместо lambda: x -> System.out.println(x)
// Ссылка на метод:
users.forEach(System.out::println);

// Вместо lambda: user -> user.getName()
// Ссылка на метод:
List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toList());

// Вместо lambda: () -> new User()
// Ссылка на конструктор:
Supplier<User> userFactory = User::new;
User newUser = userFactory.get();

// Вместо lambda: (a, b) -> Integer.compare(a, b)
// Ссылка на статический метод:
users.stream().sorted(Comparator.comparing(User::getAge));

Лучшие практики

1. Короткие лямбды

✓ Хорошо:

users.forEach(u -> System.out.println(u.getName()));

✗ Плохо:

users.forEach(user -> {
    System.out.println(user.getName());
});

2. Используй method references

✓ Хорошо:

users.stream().map(User::getName).collect(Collectors.toList());

✗ Плохо:

users.stream().map(u -> u.getName()).collect(Collectors.toList());

3. Назови переменные понятно

✓ Хорошо:

numbers.filter(n -> n > 10).map(n -> n * 2);

✗ Плохо:

numbers.filter(x -> x > 10).map(y -> y * 2);

4. Для сложной логики используй обычные методы

✓ Хорошо:

users.stream()
    .filter(this::isValidUser)
    .collect(Collectors.toList());

private boolean isValidUser(User user) {
    return user.isActive() && user.getAge() >= 18 && isNotBanned(user);
}

✗ Плохо:

users.stream()
    .filter(user -> user.isActive() && user.getAge() >= 18 && isNotBanned(user))
    .collect(Collectors.toList());

Когда использовать лямбды

✅ Используй лямбды:

• Со Stream API
• Для простых callbacks
• Для функциональных интерфейсов
• Когда код становится понятнее

❌ Не используй лямбды:

• Когда логика очень сложная (> 5-10 строк)
• Когда нужны проверки исключений
• Когда нужны loop переменные (break, continue)
• Когда это делает код менее понятным

Итоги

Лямбда-выражения - это:

• Нужны для современной Java разработки
• Упрощают работу со Stream API
• Делают код более читаемым и компактным
• Наибольшие преимущества в функциональном стиле
• Должны использоваться разумно - не переусложнять

Я активно использую лямбды в своём коде для работы с collections, Stream API и callback-функциями, но соблюдаю балас между лаконичностью и читаемостью.