Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

1
resposta

[Sugestão] Gerador primos

Uma forma que eu fiz o desafio de gerar numeros primos (nesse caso, abordei também conhecimento de listas, então se ainda não conhecem, ignorem - é o módulo seguinte):

package orientacao3.numerosPrimos;

import java.util.ArrayList;
import java.util.List;

public class NumerosPrimos {
    protected int numero;

    public void setNumero(int numero) {
        this.numero = numero;
    }
    public boolean verificaPrimalidade(int num) {
        int qtdDivisor = 0;
        for (int i = 1; i <= num; i++) {
            if (num % i == 0) {
                qtdDivisor++;
            }
        }
        return qtdDivisor == 2;
    }
    protected List<Integer> listarPrimos(int limiteSuperior) {
        List<Integer> lista = new ArrayList<>();

        int numeroAtual = 1;
        while (numeroAtual < limiteSuperior) {
            numeroAtual++;
            if (verificaPrimalidade(numeroAtual)) {
                lista.add(numeroAtual);
            }
        }
        int ultimoInteiro = lista.get(lista.size() - 1);
        while (ultimoInteiro <= numero) {
            numeroAtual++;
            if (verificaPrimalidade(numeroAtual)) {
                ultimoInteiro = numeroAtual;
                lista.add(ultimoInteiro);
            }
        }
        return lista;
    }
    public void listarPrimosFormatado(int limiteSuperior) {
        StringBuilder texto = new StringBuilder("Lista de primos: ");
        for (Integer primo : listarPrimos(limiteSuperior)) {
            int ultimo = listarPrimos(limiteSuperior).get(listarPrimos(limiteSuperior).size() - 1);
            if (primo != ultimo) {
                 texto.append(primo).append(", ");
            }
        }
        System.out.println(texto.substring(0, texto.length()-2));
    }
}
package orientacao3.numerosPrimos;

import java.util.List;

public class GeradorPrimo extends NumerosPrimos {
    public void gerarProximoPrimo() {
        List<Integer> primos = listarPrimos(numero);
        int proxPrimo = primos.get(primos.size() - 1);
        System.out.println("Próximo inteiro: " + proxPrimo);
    }
}
package orientacao3.numerosPrimos;

public class VerificadorPrimo extends NumerosPrimos {
    public void verificarSePrimo() {
        if (verificaPrimalidade(numero)) {
            System.out.println("O número " + numero + " é primo");
            return;
        }
        System.out.println("O número " + numero + " não é primo");
    }
}
package orientacao3.numerosPrimos;

public class Principal {
    public static void main(String[] args) {
        int numero = 33;

        VerificadorPrimo num = new VerificadorPrimo();
        num.setNumero(numero);
        num.verificarSePrimo();

        GeradorPrimo prox = new GeradorPrimo();
        prox.setNumero(numero);
        prox.listarPrimosFormatado(numero);
        prox.gerarProximoPrimo();
    }
}

A ideia foi mais dar o número, a lista de primos anteriores e o próximo primo, mas com tudo calculado na classe super.

1 resposta

Fala, Roger! Tudo bom?

Agradeço por trazer sua solução para o fórum!

Curti demais como trabalhou a classe NumerosPrimos para organizar a lógica em Java, entendeu perfeitamente a importância da função verificaPrimalidade para validar se um número é primo e usou bem a herança com GeradorPrimo e VerificadorPrimo para separar responsabilidades e deixar o código mais modular.

Algo bem legal para complementar é otimizar a verificação de primalidade, já que não é necessário testar todos os divisores até o número, apenas até sua raiz quadrada. Dessa maneira:

public boolean verificaPrimalidade(int num) {
    if (num <= 1) return false;
    if (num == 2) return true;
    if (num % 2 == 0) return false;

    for (int i = 3; i <= Math.sqrt(num); i += 2) {
        if (num % i == 0) {
            return false;
        }
    }
    return true;
}

Isso faz com que o programa seja mais eficiente, principalmente para números grandes.

E algumas boas práticas que você pode adotar são:

  • Legibilidade: usar nomes de variáveis mais claros, como ultimoPrimo em vez de ultimoInteiro.
  • Eficiência: evitar chamadas repetidas a listarPrimos(limiteSuperior) dentro do loop de formatação.
  • Generalização: permitir que o usuário informe o limite superior via entrada, tornando o programa mais interativo.

Continue postando as suas soluções! Além de ganhar pontos de XP na plataforma, você pode ajudar outros estudantes no fórum.

Ah, uma pergunta: você prefere evoluir esse projeto para verificar e listar primos ou já pensa em incluir funcionalidades como gerar intervalos de primos e medir desempenho para números maiores?

Fico à disposição! E se precisar, conte sempre com o apoio do fórum.

Abraço e bons estudos!

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