Solucionado (ver solução)
Solucionado
(ver solução)
1
resposta

Desafios

1º DESAFIO

public class Principal {

        public static void main(String[] args) {
            List<String> input = Arrays.asList("10", "abc", "20", "30x","100", "1oo", "26","Bárbara");

            List<Integer> soNumeros = new ArrayList();

            for(String s : input){
                try {
                    soNumeros.add(Integer.parseInt(s));
                } catch (NumberFormatException e){

                }
            }
            System.out.println("NOVA LISTA: " + soNumeros );
        }
    }

2º DESAFIO

public class Principal {
    public static void main(String[] args) {

        System.out.println(ProcessaNumero.processaNumero(Optional.of(5)));
        System.out.println(ProcessaNumero.processaNumero(Optional.of(-3)));
        System.out.println(ProcessaNumero.processaNumero(Optional.empty()));
        }
    }
public class ProcessaNumero {
            public static Optional<Integer> processaNumero(Optional<Integer> numero) {
                if (numero.isPresent() && numero.get() > 0){
                    return Optional.of(numero.get() * numero.get());
                } return Optional.empty();
            }
    }

3º DESAFIO

public class Principal {
    public static void main(String[] args) {
        System.out.println(ObterPalavra.obterPrimeiroEUltimoNome("  João Carlos Silva   ")); // Saída: "João Silva"
        System.out.println(ObterPalavra.obterPrimeiroEUltimoNome("Maria   "));

        }
    }
public class ObterPalavra {

    public static String obterPrimeiroEUltimoNome(String nomeCompleto) {
        String nomeLimpo =  nomeCompleto.trim().replaceAll("\\s", " ");

        String[] partes = nomeLimpo.split(" ");

        return "Primeiro nome: " + partes[0] + "\n" +
                "Último nome: " + partes[partes.length - 1];
    }
}

4º DESAFIO

public class Palindromo {

    public static boolean ehPalindromo(String palavra) {
        String OrganizandoNomeOuFrase = palavra.replaceAll("\\s", "");

        String invertido = new StringBuilder(OrganizandoNomeOuFrase)
                .reverse()
                .toString();

        return OrganizandoNomeOuFrase.equals(invertido);

    }
}
public class Principal {
    public static void main(String[] args) {
        System.out.println(Palindromo.ehPalindromo("socorram me subi no onibus em marrocos")); // Saída: true
        System.out.println(Palindromo.ehPalindromo("Java")); // Saída: false

        }
    }

5º DESAFIO

public class Principal {
    public static void main(String[] args) {
        List<String> emails = Arrays.asList("TESTE@EXEMPLO.COM", "exemplo@Java.com ", "Usuario@teste.Com");
        System.out.println(minusculas.converterEmails(emails));

        }
    }
public class minusculas {
    public static List<String> converterEmails(List<String> emails) {
        List<String> tudoMinusculo = emails.stream()
                .map(s -> s.toLowerCase())
                .toList();

        return tudoMinusculo;
    }
}

6º DESAFIO

public enum Mes {
    JANEIRO(31),
    FEVEREIRO(28),
    MARÇO(31),
    ABRIL(30),
    MAIO(31),
    JUNHO(30),
    JULHO(31),
    AGOSTO(31),
    SETEMBRO(30),
    NOVENBRO(30),
    DESEMBRO(31);

    private int dias;

    Mes(int dias){
        this.dias = dias;
    }
    public int getNumeroDeDias() {
        return dias;
    }
public class Principal {
    public static void main(String[] args) {

        Mes mes = Mes.ABRIL;

        System.out.println("O Mês de "  + mes + " tem " + mes.getNumeroDeDias() + " dias.");

        }
    }

7º DESAFIO

public class Principal {
    public static void main(String[] args) {

        Moedas Moeda = null;
        System.out.println(Moeda.DOLAR.converterPara(100)); // 19.60 (aproximado)
        System.out.println(Moeda.EURO.converterPara(100)); // 18.18 (aproximado)


        }
    }

public enum Moedas {
    DOLAR(0.20),
    EURO(0.18),
    REAL(1.00);

    private Double taxaDeConversao;

    Moedas(Double taxaDeConversao){
        this.taxaDeConversao = taxaDeConversao;
    }
    public double converterPara(double valorEmReais) {
        return valorEmReais * taxaDeConversao;
    }
}

8º DESAFIO

public enum CodigoErro {
    NOT_FOUND(404, "Recurso não encontrado"),
    BAD_REQUEST(400, "Requisição inválida"),
    INTERNAL_SERVER_ERROR(500, "Erro interno do servidor");

    private final int codigoDoErro;
    private final String descricaoDoErro;

    CodigoErro(int codigoDoErro, String descricaoDoErro) {
        this.codigoDoErro = codigoDoErro;
        this.descricaoDoErro = descricaoDoErro;
    }

    public int getCodigo() {
        return codigoDoErro;
    }

    public String getDescricao() {
        return descricaoDoErro;
    }
}
1 resposta
solução!

Oii, Bárbara! Tudo bem?

Parabéns pela dedicação em resolver todos os desafios! É muito legal ver como você aplicou conhecimentos variados, desde tratamento de exceções até o uso de Enums e Streams. O seu raciocínio lógico tá no caminho certo.

Manipulação de Strings e Regex (desafio 3)
No desafio de pegar o primeiro e último nome, você usou:
String[] partes = nomeLimpo.split(" ");

Essa abordagem funciona na maioria dos casos, mas se o usuário digitar vários espaços seguidos entre os nomes (ex: "Ana   Clara"), o split(" ") pode gerar elementos vazios no array.
Uma dica "pro" é usar o regex \\s+, que significa "um ou mais espaços":
String[] partes = nomeLimpo.split("\\s+");

Palíndromos e maiúsculas/minúsculas (desafio 4)
Sua lógica de inverter a String está ótima! Só uma dica: para garantir que "Ana" seja considerado um palíndromo igual a "ana", é legal converter tudo para minúsculo antes de comparar.
String OrganizandoNomeOuFrase = palavra.replaceAll("\\s", "").toLowerCase();

O poder do estilo funcional (desafio 2)
No desafio do Optional, você resolveu com if/else, o que funciona perfeitamente! Mas, como estamos num curso que aborda Spring Data e Streams, uma forma mais "elegante" e funcional de fazer isso seria usando os métodos do próprio Optional, sem precisar extrair o valor com .get() manualmente:

public static Optional<Integer> processaNumero(Optional<Integer> numero) {
    return numero
        .filter(n -> n > 0) // filtra se é positivo
        .map(n -> n * n);   // transforma (mapeia) para o quadrado se passar no filtro
}

Isso deixa o código mais limpo e fácil de ler!

Continue praticando assim, Bárbara.

Alura Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!