Gerador de números aleatórios Java

Aprenda como gerar números aleatórios em Java com exemplos de código interativos. Explore Random.nextInt(), SecureRandom, ThreadLocalRandom e Math.random() com explicações detalhadas.

Editor de código Java

Aprenda como gerar números aleatórios em Java com exemplos de código interativos. Explore Random.nextInt(), SecureRandom, ThreadLocalRandom e Math.random() com explicações detalhadas.

import java.util.Random;

public class RandomExample {
    public static void main(String[] args) {
        Random rand = new Random();
        int min = 1;
        int max = 100;
        int quantity = 5;

        System.out.println("Random numbers between " + min + " and " + max + ":");
        for (int i = 0; i < quantity; i++) {
            int num = rand.nextInt(max - min + 1) + min;
            System.out.print(num + " ");
        }
    }
}

Saída

É uma pré-visualização no navegador, sem executar Java ou C++. Os valores não servem para criptografia.

Pré-visualizar exemplo

Aleatório básico com java.util.Random

Use Random.nextInt() para gerar números inteiros aleatórios em um intervalo específico. Este é o método mais comum para geração de números aleatórios de uso geral em Java.

Precisa de um número aleatório rápido?

Experimente nosso aleatório on-line gerador de números para resultados instantâneos sem escrever nenhum código.

Gerador de números aleatórios abertos

Compreendendo a geração de números aleatórios em Java

Java fornece várias maneiras de gerar números aleatórios, cada uma otimizada para diferentes casos de uso. java.util.Random usa um algoritmo Linear Congruential Generator (LCG), SecureRandom fornece números aleatórios criptograficamente fortes, ThreadLocalRandom oferece geração segura de thread para aplicativos simultâneos e Math.random() fornece uma maneira simples de gerar duplas aleatórias. jogos e tarefas gerais de programação. Thread-safe para uso básico.

java.util.Random

java.util.Random oferece geração rápida de números pseudo-aleatórios adequada para simulações, jogos e tarefas gerais de programação. Seguro para uso básico.

SecureRandom

java.security.SecureRandom usa algoritmos específicos da plataforma (SHA1PRNG, NativePRNG) para gerar números aleatórios criptograficamente seguros para aplicativos de segurança.

ThreadLocalAleatório

ThreadLocalRandom fornece geração eficiente de números aleatórios thread-safe projetados especificamente para aplicativos multithread, evitando contenção e sobrecarga de sincronização.

Math.random()

Math.random() é um método simples que retorna um valor duplo entre 0,0 e 1,0. Conveniente para cálculos rápidos, mas menos flexível do que outras opções.

Casos de uso comuns

Jogos e simulações

Gere lançamentos aleatórios de dados, sorteios de cartas, spawns de inimigos e eventos de jogo usando Random.nextInt() ou ThreadLocalRandom em loops de jogo.

Segurança e criptografia

Crie senhas seguras, chaves de API, tokens de sessão e sais de criptografia usando SecureRandom para obter aleatoriedade de força criptográfica.

Aplicativos simultâneos

Use ThreadLocalRandom em fluxos paralelos e aplicativos multithread para evitar contenção e melhorar o desempenho.

Teste de software

Crie dados de teste aleatórios, entradas de teste fuzz e casos extremos para garantir cobertura de código robusta e detecção de bugs em aplicativos Java.

Como funciona a geração de números aleatórios em Java

A classe java.util.Random do Java usa um algoritmo Linear Congruential Generator (LCG) com uma semente de 48 bits. Ele fornece uma maneira simples de gerar números pseudo-aleatórios e é sincronizado para segurança de thread.

A classe SecureRandom fornece números aleatórios criptograficamente fortes usando implementações específicas da plataforma. Na maioria dos sistemas, ele usa a fonte de entropia do sistema operacional ou geradores de números aleatórios de hardware.

ThreadLocalRandom, introduzido no Java 7, foi projetado para aplicativos multithread. Ele usa um gerador de números aleatórios que é isolado do thread atual, evitando sobrecarga de sincronização e contenção.

Sugestões práticas

🎯

Escolha a API certa

Use Random para casos simples, SecureRandom para segurança, ThreadLocalRandom para aplicativos simultâneos e Math.random() apenas para protótipos rápidos. Cada um tem casos de uso específicos.

🔒

Sempre use SecureRandom para segurança

Nunca use Random ou Math.random() para senhas, tokens ou operações criptográficas. Sempre use SecureRandom para garantir uma forte aleatoriedade e evitar padrões previsíveis.

⚡

Otimizar para acesso simultâneo

Em aplicativos multithread, ThreadLocalRandom é significativamente mais rápido do que sincronizar objetos aleatórios. Use-o em fluxos paralelos e coleções simultâneas.

Especificações técnicas

Algoritmos

  • Gerador Congruente Linear (classe Random)
  • SHA1PRNG ou NativePRNG (SecureRandom)
  • ThreadLocalRandom (Java 7+, baseado em Random)
  • Pseudo-aleatório duplo (Math.random())

Características de desempenho

  • Math.random(): mais rápido para duplas simples
  • ThreadLocalRandom: melhor para acesso simultâneo
  • Aleatório: boa sobrecarga sincronizada de uso geral
  • SecureRandom: mais lento devido à coleta de entropia

Perguntas frequentes

Que APIs de Java são abrangidas?

java.util.Random, SecureRandom, ThreadLocalRandom e Math.random(), cada uma com um exemplo dedicado.

Posso personalizar os exemplos?

Sim. Defina o mínimo, o máximo e a quantidade no painel de parâmetros e execute para ver os resultados de imediato.

Qual devo utilizar para segurança?

SecureRandom. As outras APIs são previsíveis e não devem ser usadas para gerar tokens, chaves ou palavras-passe.

E em código multithread?

O ThreadLocalRandom evita a contenção entre threads e é a escolha habitual em streams paralelas e pools de threads.

Como gero um número aleatório entre dois valores em Java?

Chame nextInt(bound) para obter valores de 0 até bound-1, pelo que nextInt(50) gera de 0 a 49. Para um intervalo personalizado, adicione um desvio: nextInt(10) + 5 produz de 5 a 14. Desde o Java 17, nextInt(origin, bound) faz isto numa única chamada, em que origin é inclusivo e bound é exclusivo.

O Math.random() pode devolver 1?

Não. O Math.random() devolve um double a partir de 0.0, inclusive, até 1.0, exclusive, pelo que podem surgir 0.0 ou 0.9999, mas 1.0 nunca aparece. Internamente, delega numa única instância de java.util.Random, pelo que chamar diretamente os métodos de Random é mais claro em código moderno.

Porque é que obtenho os mesmos números aleatórios sempre que executo o meu programa?

Uma Random criada com uma seed fixa, como new Random(42), reproduz sempre exatamente a mesma sequência. Remova o argumento da seed e ela é inicializada automaticamente a partir de um valor único combinado com System.nanoTime(). As seeds fixas são úteis para testes reprodutíveis e para depuração, mas devem ficar fora do código de produção.

Como escolho um elemento aleatório de um array ou de uma lista?

Gere um índice e leia essa posição: list.get(random.nextInt(list.size())) para listas ou array[random.nextInt(array.length)] para arrays, uma vez que nextInt(n) abrange de 0 a n-1. Em alternativa, Collections.shuffle() aleatoriza toda a ordem da lista numa única passagem, pelo que nenhum elemento se repete numa única baralhagem.

Referências e recursos