Какой объект вернется при вызове forEach?

Что возвращает forEach в Java

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

forEach НЕ возвращает ничего — это метод, возвращающий void. Он выполняет действие для каждого элемента, но не возвращает объект.

public interface Consumer<T> {
    void accept(T t);
}

// forEach имеет сигнатуру
public void forEach(Consumer<? super T> action)

Различные контексты использования forEach

1. forEach в Iterable (самый частый случай)

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

// forEach НИЧЕГО не возвращает
names.forEach(name -> System.out.println(name));
// Вывод:
// Alice
// Bob
// Charlie

// Это эквивалентно
for (String name : names) {
    System.out.println(name);
}

Важно: это операция-действие, не функция-трансформация.

2. forEach в Stream API

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

// Stream.forEach тоже НИЧЕГО не возвращает
numbers.stream()
    .filter(n -> n > 2)
    .forEach(n -> System.out.println(n * 2)); // void

// Вывод: 6 8 10

В Stream это terminal operation (заканчивает цепь):

// ✅ Это работает
List<Integer> result = numbers.stream()
    .filter(n -> n > 2)
    .map(n -> n * 2)
    .collect(Collectors.toList()); // Возвращает List!

// ❌ Это НЕ работает
List<Integer> result = numbers.stream()
    .filter(n -> n > 2)
    .forEach(n -> System.out.println(n)); // void, не List!

3. Синтаксис forEach

public class ForEachExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob");
        
        // Вариант 1: Lambda
        names.forEach(name -> System.out.println(name));
        
        // Вариант 2: Method reference
        names.forEach(System.out::println);
        
        // Вариант 3: Анонимный класс
        names.forEach(new Consumer<String>() {
            @Override
            public void accept(String name) {
                System.out.println(name);
            }
        });
        
        // Все три варианта НИЧЕГО не возвращают
    }
}

Различие: forEach vs map

Это частая путаница:

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

// ❌ НЕПРАВИЛЬНО - forEach не возвращает значение
List<Integer> doubled = numbers.forEach(n -> n * 2); // ОШИБКА КОМПИЛЯЦИИ!
// Variable doubled might not have been initialized

// ✅ ПРАВИЛЬНО - используй map для трансформации
List<Integer> doubled = numbers.stream()
    .map(n -> n * 2)
    .collect(Collectors.toList()); // [2, 4, 6]

// ✅ ПРАВИЛЬНО - используй forEach для побочных эффектов
numbers.forEach(n -> System.out.println(n * 2));
// Побочный эффект: вывод в консоль

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

// ✅ ПРАВИЛЬНОЕ использование forEach

// 1. Логирование
users.forEach(user -> logger.info("Processing: {}", user.getName()));

// 2. Сохранение в БД
users.forEach(user -> database.save(user));

// 3. Отправка сообщений
emails.forEach(email -> emailService.send(email));

// 4. Обновление состояния
accounts.forEach(acc -> acc.applyInterest(0.05));

// 5. I/O операции
files.forEach(file -> file.delete());

// ❌ НЕПРАВИЛЬНОЕ использование forEach

// Не используй forEach для преобразования данных
List<String> uppercase = names.forEach(n -> n.toUpperCase()); // ОШИБКА
// Используй map вместо этого
List<String> uppercase = names.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Возвращаемые типы в Stream API

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

// TERMINAL OPERATIONS (заканчивают цепь и возвращают результат)

// collect() - возвращает Collection
List<Integer> list = numbers.stream()
    .filter(n -> n > 2)
    .collect(Collectors.toList()); // List<Integer>

// forEach() - НИЧЕГО не возвращает (void)
numbers.stream()
    .filter(n -> n > 2)
    .forEach(System.out::println); // void

// reduce() - возвращает Optional или значение
Optional<Integer> sum = numbers.stream()
    .reduce((a, b) -> a + b); // Optional<Integer>

// count() - возвращает long
long count = numbers.stream()
    .filter(n -> n > 2)
    .count(); // 3

// anyMatch() - возвращает boolean
boolean hasOdd = numbers.stream()
    .anyMatch(n -> n % 2 == 1); // true

// findFirst() - возвращает Optional
Optional<Integer> first = numbers.stream()
    .findFirst(); // Optional[1]

// min/max - возвращают Optional
Optional<Integer> min = numbers.stream()
    .min(Integer::compare); // Optional[1]

Практический пример: когда использовать что

@Service
public class UserService {
    @Autowired
    private UserRepository repo;
    
    @Autowired
    private EmailService emailService;
    
    // Пример 1: НЕПРАВИЛЬНО - используешь forEach для collect
    public void badExample(List<User> users) {
        List<String> names = new ArrayList<>();
        users.forEach(user -> names.add(user.getName())); // ❌ Работает, но плохо
    }
    
    // Пример 1: ПРАВИЛЬНО
    public List<String> goodExample(List<User> users) {
        return users.stream()
            .map(User::getName)
            .collect(Collectors.toList()); // ✅ Правильно
    }
    
    // Пример 2: ПРАВИЛЬНОЕ использование forEach
    @Transactional
    public void processAllUsers() {
        List<User> users = repo.findAll();
        
        // forEach для побочных эффектов
        users.forEach(user -> {
            user.updateLastSeen();
            emailService.sendNotification(user);
        }); // void
    }
    
    // Пример 3: forEach с обработкой исключений
    public void processWithErrors(List<User> users) {
        users.forEach(user -> {
            try {
                sendNotification(user);
            } catch (Exception e) {
                logger.error("Failed to process user: {}", user.getId(), e);
            }
        });
    }
}

Параллельный forEach

List<User> users = fetchLargeUserList();

// Последовательный forEach
users.forEach(user -> processUser(user)); // Медленно для больших данных

// Параллельный forEach (parallel stream)
users.parallelStream()
    .forEach(user -> processUser(user)); // Быстрее благодаря многопоточности

// Важно: forEach НЕ возвращает ничего и в параллельном случае!

Выводы

1. forEach НИЧЕГО не возвращает — это void операция

2. forEach используется для:

   • Побочных эффектов (логирование, запись в БД)
   • Операций с миром вне функции (I/O, сетевые запросы)

3. Для трансформации данных используй:

   • map() для преобразования элементов
   • collect() для сбора результатов
   • reduce() для агрегации

4. Помни различие:

   • forEach (void) → для побочных эффектов
   • map (Stream) → для преобразования
   • collect (Collection) → для сбора результата

5. Правило: если нужен результат — НЕ используй forEach