Где применяется Consumer?

Где применяется Consumer

Consumer — это один из самых полезных функциональных интерфейсов в Java, представляющий операцию, которая принимает один параметр и ничего не возвращает (void).

Определение Consumer

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

Ключевые характеристики:

• Принимает один параметр типа T
• Ничего не возвращает (void)
• Обычно используется для побочных эффектов (side effects)
• Может быть цепочкой через andThen()

1. Использование в Stream API

Iterate элементы и выполнить действие:

public class StreamConsumerExample {
    
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        
        // Consumer для вывода
        Consumer<String> printName = name -> System.out.println("Name: " + name);
        names.forEach(printName);
        
        // Или в одну строку
        names.forEach(name -> System.out.println("Name: " + name));
        
        // Работает со Stream
        names.stream()
            .filter(n -> n.length() > 3)
            .forEach(System.out::println);
    }
}

2. Обработка данных из коллекций

Обновление объектов:

public class CollectionProcessing {
    
    public static void main(String[] args) {
        List<User> users = Arrays.asList(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );
        
        // Consumer для активации пользователей
        Consumer<User> activate = user -> user.setActive(true);
        users.forEach(activate);
        
        // Consumer для логирования
        Consumer<User> log = user -> System.out.println("Processing: " + user.getName());
        users.forEach(log);
    }
}

class User {
    private int id;
    private String name;
    private boolean active;
    
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }
    
    public void setActive(boolean active) { this.active = active; }
    public String getName() { return name; }
}

3. Consumer в параметрах методов

Flexible методы через Consumer:

public class FlexibleMethods {
    
    // Метод, который принимает Consumer для обработки результата
    public void processUsers(List<User> users, Consumer<User> action) {
        for (User user : users) {
            if (user.isActive()) {
                action.accept(user);
            }
        }
    }
    
    public void sendNotification(String message, Consumer<String> handler) {
        try {
            // Обработка сообщения
            handler.accept(message);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
    
    public static void main(String[] args) {
        List<User> users = createUsers();
        FlexibleMethods processor = new FlexibleMethods();
        
        // Передаём разные Consumer'ы
        processor.processUsers(users, user -> System.out.println(user.getName()));
        processor.processUsers(users, user -> user.setActive(false));
        processor.processUsers(users, user -> sendEmailTo(user));
        
        // Для уведомлений
        processor.sendNotification("Hello", msg -> System.out.println("Log: " + msg));
        processor.sendNotification("Warning", msg -> logToDatabase(msg));
    }
}

4. BiConsumer — Consumer с двумя параметрами

BiConsumer для работы с парами:

public class BiConsumerExample {
    
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);
        
        // BiConsumer для iterating Map
        map.forEach((name, age) -> {
            System.out.println(name + " is " + age + " years old");
        });
        
        // BiConsumer для обновления значений
        Map<String, Integer> prices = new HashMap<>();
        prices.put("apple", 100);
        prices.put("banana", 50);
        
        // Увеличить цены
        prices.replaceAll((product, price) -> price + 10);
    }
}

5. Цепочки Consumer'ов с andThen()

Композиция действий:

public class ConsumerChaining {
    
    public static void main(String[] args) {
        List<String> tasks = Arrays.asList("Task 1", "Task 2", "Task 3");
        
        // Отдельные Consumer'ы
        Consumer<String> log = task -> System.out.println("Log: " + task);
        Consumer<String> execute = task -> System.out.println("Execute: " + task);
        Consumer<String> archive = task -> System.out.println("Archive: " + task);
        
        // Цепочка: log -> execute -> archive
        Consumer<String> pipeline = log.andThen(execute).andThen(archive);
        
        // Выполнить всю цепочку для каждого элемента
        tasks.forEach(pipeline);
        
        // Вывод:
        // Log: Task 1
        // Execute: Task 1
        // Archive: Task 1
        // Log: Task 2
        // ...
    }
}

6. Consumer с event listeners

Обработка событий:

public class EventHandler {
    
    private List<Consumer<UserEvent>> listeners = new ArrayList<>();
    
    // Регистрация слушателей
    public void subscribe(Consumer<UserEvent> listener) {
        listeners.add(listener);
    }
    
    // Генерация события
    public void notifyListeners(UserEvent event) {
        listeners.forEach(listener -> listener.accept(event));
    }
    
    public static void main(String[] args) {
        EventHandler handler = new EventHandler();
        
        // Подписываемся на события
        handler.subscribe(event -> System.out.println("Email sent for: " + event.getUserName()));
        handler.subscribe(event -> logEventToDatabase(event));
        handler.subscribe(event -> updateUserCache(event));
        
        // Генерируем событие
        UserEvent event = new UserEvent(1, "Alice");
        handler.notifyListeners(event);
    }
}

class UserEvent {
    private int userId;
    private String userName;
    
    public UserEvent(int userId, String userName) {
        this.userId = userId;
        this.userName = userName;
    }
    
    public String getUserName() { return userName; }
}

7. Consumer в callback паттернах

Асинхронные операции:

public class AsyncOperations {
    
    // Асинхронная загрузка данных с callback
    public void loadDataAsync(int userId, Consumer<User> onSuccess, Consumer<Exception> onError) {
        new Thread(() -> {
            try {
                Thread.sleep(1000);  // Имитация сетевой задержки
                User user = fetchUserFromDatabase(userId);
                onSuccess.accept(user);  // Успех
            } catch (Exception e) {
                onError.accept(e);  // Ошибка
            }
        }).start();
    }
    
    public static void main(String[] args) {
        AsyncOperations ops = new AsyncOperations();
        
        // Consumer для успеха
        Consumer<User> onSuccess = user -> System.out.println("Loaded: " + user.getName());
        
        // Consumer для ошибки
        Consumer<Exception> onError = error -> System.out.println("Error: " + error.getMessage());
        
        ops.loadDataAsync(1, onSuccess, onError);
    }
}

8. Consumer с Optional

Работа с Optional:

public class OptionalConsumer {
    
    public static void main(String[] args) {
        Optional<User> userOpt = Optional.of(new User(1, "Alice"));
        
        // ifPresent принимает Consumer
        userOpt.ifPresent(user -> System.out.println("User: " + user.getName()));
        
        // Более сложный пример
        Optional<String> nameOpt = Optional.of("Bob");
        nameOpt.ifPresentOrElse(
            name -> System.out.println("Found: " + name),  // Consumer
            () -> System.out.println("Not found")           // Runnable
        );
        
        // Цепочка
        Optional.of(new User(1, "Charlie"))
            .ifPresent(user -> {
                user.setActive(true);
                System.out.println("Activated: " + user.getName());
            });
    }
}

9. Реальный пример: обработка конфигурации

public class ConfigurationManager {
    
    private Map<String, Consumer<String>> handlers = new HashMap<>();
    
    public ConfigurationManager() {
        // Регистрируем обработчики конфигурации
        handlers.put("database.url", url -> setupDatabase(url));
        handlers.put("cache.enabled", enabled -> setupCache(Boolean.parseBoolean(enabled)));
        handlers.put("log.level", level -> setupLogging(level));
    }
    
    public void applyConfig(Map<String, String> config) {
        config.forEach((key, value) -> {
            Consumer<String> handler = handlers.get(key);
            if (handler != null) {
                handler.accept(value);
            }
        });
    }
    
    private void setupDatabase(String url) { /* ... */ }
    private void setupCache(boolean enabled) { /* ... */ }
    private void setupLogging(String level) { /* ... */ }
}

10. Consumer с Collections.sort()

public class SortingWithConsumer {
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
        
        // Consumer для логирования сортировки
        Consumer<Integer> log = num -> System.out.println("Processing: " + num);
        
        // Сортируем и логируем
        numbers.sort(Integer::compare);
        numbers.forEach(log);
    }
}

Практические применения Consumer'a

Best Practices

// ✅ Хорошо: Consumer для побочных эффектов
List<User> users = getUsers();
users.forEach(user -> sendEmail(user));  // Consumer для действия

// ✅ Хорошо: Композиция Consumer'ов
Consumer<User> log = u -> System.out.println(u);
Consumer<User> save = u -> database.save(u);
users.forEach(log.andThen(save));

// ❌ Неправильно: для преобразования используй Function
List<Integer> numbers = Arrays.asList(1, 2, 3);
// Неправильно использовать Consumer для преобразования

// ✅ Правильно: используй Function
List<String> strings = numbers.stream()
    .map(String::valueOf)  // Function<Integer, String>
    .collect(Collectors.toList());

Итог

Consumer используется для:

1. Iteration — forEach() в Stream'ах и коллекциях
2. Callbacks — асинхронные операции и event handlers
3. Побочные эффекты — логирование, сохранение, отправка
4. Композиция — цепочки действий через andThen()
5. Гибкие методы — параметризация поведения
6. Event-driven архитектура — подписка на события

Consumer — это фундамент функционального программирования в Java, позволяющий писать чистый, переиспользуемый и композируемый код.