Какой функциональный интерфейс принимает метод forEach в качестве аргумента?

Функциональный интерфейс Consumer в forEach

Метод forEach() принимает функциональный интерфейс Consumer в качестве аргумента. Это фундаментальная часть функционального программирования в Java.

Consumer Интерфейс

Consumer<T> — это функциональный интерфейс из пакета java.util.function, который принимает один аргумент и не возвращает ничего (void).

Сигнатура:

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
    
    // default методы для цепирования
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Использование Consumer в forEach

На Collections

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

// Consumer как lambda выражение
names.forEach(name -> System.out.println(name));

// Consumer как method reference
names.forEach(System.out::println);

// Эквивалент с явным Consumer
Consumer<String> printConsumer = System.out::println;
names.forEach(printConsumer);

На Stream

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

// Consumer в forEach на Stream
numbers.stream()
    .forEach(n -> System.out.println("Number: " + n));

// Consumer с более сложной логикой
numbers.stream()
    .forEach(n -> {
        if (n % 2 == 0) {
            System.out.println(n + " is even");
        }
    });

Примеры Consumer

Простой Consumer

// Consumer для вывода
Consumer<String> printer = s -> System.out.println(s);
printer.accept("Hello World");

// Consumer для модификации объекта
Consumer<User> activateUser = user -> user.setActive(true);
User user = new User("Alice");
activateUser.accept(user);

// Consumer для добавления в коллекцию
List<String> result = new ArrayList<>();
Consumer<String> adder = result::add;
adder.accept("First");
adder.accept("Second");

Consumer для различных операций

// Consumer для отправки email
Consumer<User> sendEmail = user -> 
    emailService.send(user.getEmail(), "Welcome!");

// Consumer для логирования
Consumer<Event> logger = event -> 
    log.info("Event occurred: " + event);

// Consumer для обновления БД
Consumer<User> updateDatabase = user -> 
    userRepository.save(user);

// Consumer для валидации
Consumer<User> validator = user -> {
    if (user.getEmail() == null) {
        throw new IllegalArgumentException("Email required");
    }
};

Consumer vs другие функциональные интерфейсы

// Consumer<T> — принимает T, ничего не возвращает
Consumer<String> consumer = s -> System.out.println(s);

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

// Predicate<T> — принимает T, возвращает boolean
Predicate<String> predicate = s -> s.length() > 0;

// Supplier<T> — ничего не принимает, возвращает T
Supplier<String> supplier = () -> "Hello";

// BiConsumer<T, U> — принимает T и U, ничего не возвращает
BiConsumer<String, Integer> biConsumer = (s, i) -> 
    System.out.println(s + ": " + i);

Цепирование Consumer (andThen)

// Цепирование с andThen
Consumer<String> first = s -> System.out.println("First: " + s);
Consumer<String> second = s -> System.out.println("Second: " + s);

Consumer<String> combined = first.andThen(second);

List<String> list = Arrays.asList("A", "B");
list.forEach(combined);

// Вывод:
// First: A
// Second: A
// First: B
// Second: B

Практические примеры

Пример 1: Обновление объектов

@Service
public class UserService {
    
    public void updateAllUsers(List<User> users, Consumer<User> updater) {
        users.forEach(updater);
    }
}

// Использование
List<User> users = userRepository.findAll();
userService.updateAllUsers(users, user -> {
    user.setLastLogin(LocalDateTime.now());
    userRepository.save(user);
});

Пример 2: Логирование операций

public class LoggingUtils {
    
    public static <T> Consumer<T> withLogging(Consumer<T> consumer, String action) {
        return item -> {
            log.info("Starting action: " + action);
            consumer.accept(item);
            log.info("Completed action: " + action);
        };
    }
}

// Использование
List<String> items = Arrays.asList("item1", "item2");
Consumer<String> loggedPrinter = LoggingUtils.withLogging(
    System.out::println, 
    "printing"
);
items.forEach(loggedPrinter);

Пример 3: Builder pattern с Consumer

public class MailBuilder {
    private String to;
    private String subject;
    private String body;
    
    public static void sendMail(Consumer<MailBuilder> builder) {
        MailBuilder mail = new MailBuilder();
        builder.accept(mail);
        mail.send();
    }
    
    private void send() {
        // Отправка email
    }
}

// Использование
MailBuilder.sendMail(mail -> {
    mail.to = "user@example.com";
    mail.subject = "Hello";
    mail.body = "Welcome!";
});

BiConsumer и другие варианты

BiConsumer<T, U> — Consumer, который принимает два аргумента:

// Для Map
Map<String, Integer> map = new HashMap<>();
map.put("Alice", 30);
map.put("Bob", 25);

// forEach на Map использует BiConsumer
map.forEach((name, age) -> 
    System.out.println(name + " is " + age + " years old")
);

// Явное использование BiConsumer
BiConsumer<String, Integer> printPair = (k, v) -> 
    System.out.println(k + "=" + v);

map.forEach(printPair);

Типичные Consumer операции

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

// 1. Вывод
numbers.forEach(System.out::println);

// 2. Модификация состояния
List<Integer> doubled = new ArrayList<>();
numbers.forEach(n -> doubled.add(n * 2));

// 3. Вызов методов
numbers.forEach(n -> logger.log("Number: " + n));

// 4. Условное выполнение
numbers.forEach(n -> {
    if (n > 2) {
        System.out.println(n);
    }
});

// 5. Исключение
numbers.forEach(n -> {
    if (n > 10) {
        throw new IllegalArgumentException("Too large");
    }
});

Лучшие практики использования Consumer

1. Простые операции — используйте lambda:

list.forEach(item -> System.out.println(item));

1. Сложные операции — выделите в метод:

private void processItem(Item item) {
    // Сложная логика
}
list.forEach(this::processItem);

1. Повторяющиеся Consumer — создавайте переменные:

Consumer<User> updateUser = user -> userRepository.save(user);
list.forEach(updateUser);

1. Цепирование — используйте andThen:

Consumer<Data> validate = ...;
Consumer<Data> save = ...;
list.forEach(validate.andThen(save));

Вывод: Метод forEach() принимает Consumer<T> функциональный интерфейс. Consumer принимает один аргумент типа T и не возвращает ничего (void). Это основной инструмент для выполнения побочных эффектов при итерации по коллекциям и потокам.