O que é o método de recursão em Stream?

// A recursão na Stream API não é suportada diretamente.  
// O método chama-se reduce.  

O método reduce na Stream API realiza uma redução dos elementos do fluxo em um único valor resultante, aplicando uma operação binária.

Existem três sobrecargas do método reduce:

1. Optional<T> reduce(BinaryOperator<T> accumulator): Aplica o operador de redução aos elementos do fluxo, retornando um Optional<T>. É usado quando não há um valor inicial.

2. T reduce(T identity, BinaryOperator<T> accumulator): Aplica o operador de redução começando com um valor inicial (identity). Retorna um valor resultante do tipo T.

3. <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner): Forma mais geral, adequada para fluxos paralelos.

   • identity: Valor inicial do acumulador.
   • accumulator: Combina um elemento do fluxo com o acumulador.
   • combiner: Combina os resultados de cálculos paralelos.

Exemplo de uso:

import java.util.Arrays;  
import java.util.List;  
import java.util.Optional;  

public class StreamReduceExample {  

    public static void main(String[] args) {  
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);  

        // Exemplo 1: Soma dos elementos sem valor inicial  
        Optional<Integer> sumOptional = numbers.stream()  
                                              .reduce((a, b) -> a + b);  
        sumOptional.ifPresent(sum -> System.out.println("Soma (Optional): " + sum));  

        // Exemplo 2: Soma dos elementos com valor inicial  
        int sumWithIdentity = numbers.stream()  
                                     .reduce(0, (a, b) -> a + b);  
        System.out.println("Soma (com identidade): " + sumWithIdentity);  

        // Exemplo 3: Concatenação de strings com fluxo paralelo  
        List<String> words = Arrays.asList("Hello", " ", "World", "!");  
        String combinedString = words.parallelStream()  
                                     .reduce("", // identidade  
                                             (a, b) -> a + b, // acumulador  
                                             (a, b) -> a + b); // combinador  
        System.out.println("String combinada: " + combinedString);  
    }  
}