[Desafio] Trabalhando com Streams e Collections

Busquei unir todos os exercícios em um programa só:

package com.desafio_streams.desafio;

import com.desafio_streams.desafio.model.Pessoa;
import org.apache.commons.lang3.StringUtils; //Requer a dependência Apache Commons StringUtils
import org.apache.commons.math3.primes.Primes; //Requer a dependência Apache Commons Math
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@SpringBootApplication
public class DesafioAluraDeStreamsApplication implements CommandLineRunner {

    public static void main(String[] args) {
        SpringApplication.run(DesafioAluraDeStreamsApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        filtrarPares();
        transformarStrings();
        filtrarEManipularNumeros();
        removerDuplicadosEImprimir();
        filtrarPrimos();
        filtrarPessoas();
    }

    /**
     * 1. Dada a lista de números inteiros abaixo, filtre apenas os números pares e imprima-os.
     */
    private void filtrarPares() {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6);
        System.out.println("Desafio 1: " + numeros.stream()
                .filter(n -> n % 2 == 0)
                .map(String::valueOf)
                .collect(Collectors.joining(", ")));
    }

    /**
     * 2. Imprimir strings transformadas em maiúsculas
     */
    private void transformarStrings() {
        List<String> palavras = Arrays.asList("java", "stream", "lambda");
        System.out.println("Desafio 2: " + palavras.stream()
                .map(s -> s.toUpperCase())
                .collect(Collectors.joining(", ")));
    }

    /**
     * 3. Filtrar números ímpares, multiplicar por 2 e colocar em uma nova lista
     */
    private void filtrarEManipularNumeros() {
        List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> numerosFiltrados = numeros.stream()
                .filter(n -> n % 2 == 1)
                .map(n -> n * 2)
                .collect(Collectors.toList());
        System.out.println("Desafio 3: " + numerosFiltrados);
    }

    /**
     * 4. Remover duplicadas e imprimir resultado
     */
    private void removerDuplicadosEImprimir() {
        List<String> palavras = Arrays.asList("apple", "banana", "apple", "orange", "banana");
        System.out.println("Desafio 4: " + palavras.stream()
                .distinct()
                .map(StringUtils::capitalize)
                .collect(Collectors.joining(", ")));
    }

    /**
     * 5. Dada a lista de sublistas de números inteiros abaixo,
     * extraia todos os números primos em uma única lista e
     * os ordene em ordem crescente.
     */
    private void filtrarPrimos() {
        List<List<Integer>> listaDeNumeros = Arrays.asList(
                Arrays.asList(1, 2, 3, 4),
                Arrays.asList(5, 6, 7, 8),
                Arrays.asList(9, 10, 11, 12)
        );

        List<Integer> numerosPrimos = listaDeNumeros.stream()
                .flatMap(List::stream)
                .filter(n -> Primes.isPrime(n))
                .sorted()
                .collect(Collectors.toList());

        System.out.println("Desafio 5: " + numerosPrimos.stream()
                .map(String::valueOf)
                .collect(Collectors.joining(", "))
        );
    }

    /**
     * 6. Dado um objeto Pessoa com os campos nome e idade,
     * filtre as pessoas com mais de 18 anos, extraia os
     * nomes e imprima-os em ordem alfabética.
     */
    private void filtrarPessoas() {
        List<Pessoa> pessoas = Arrays.asList(
                new Pessoa("Alice", 22),
                new Pessoa("Bob", 17),
                new Pessoa("Charlie", 19)
        );
        System.out.println("Desafio 6: " + pessoas.stream()
                .filter(p -> p.getIdade() >= 18)
                .map(Pessoa::getNome)
                .sorted()
                .collect(Collectors.joining(", "))
        );
    }
}

Para que o código funcione, é necessário adicionar as dependências a seguir no pom.xml:

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-math3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-math3</artifactId>
            <version>3.6.1</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.18.0</version>
        </dependency>

Busquei também organizar a impressão dos resultados para que o console ficasse mais fácil de ler.