A necessidade de gerar números aleatórios dentro de um intervalo definido é uma tarefa comum no desenvolvimento de software. Seja para simulações, testes, jogos ou para introduzir variabilidade em alguma lógica de negócio, a linguagem Java oferece a clase java.util.Random para essa finalidade. Compreender como utilizá-la para obter valores em um intervalo inclusivo [min, max] é fundamental.

A classe Random possui um método chave: nextInt(int bound). Este método retorna um valor inteiro pseudoaleatório que varia de 0 (inclusive) até bound (exclusivo). Em notação matemática, o intervalo é [0, bound). Por exemplo, new Random().nextInt(100) gerará um número entre 0 e 99.

Gerando Números em um Intervalo Básico

Vamos considerar o caso de querer gerar números aleatórios no intervalo [1, 100], ou seja, incluindo tanto o 1 quanto o 100. Como nextInt(100) nos dá números de [0, 99], podemos simplesmente adicionar 1 ao resultado para deslocar o intervalo para [1, 100]. Assim, new Random().nextInt(100) + 1 atingirá o objetivo.

Considere o exemplo a seguir, que demonstra a geração de dez números neste intervalo:

import java.util.Random;

public class GeradorDeFaixa {
    public static void main(String[] args) {
        Random geradorNumeros = new Random();
        int minimoDesejado = 1;
        int maximoDesejado = 100;

        System.out.println("Gerando 10 inteiros aleatórios no intervalo [" + minimoDesejado + ", " + maximoDesejado + "]:");
        for (int contagem = 0; contagem < 10; contagem++) {
            // O método nextInt(N) gera números de 0 a N-1.
            // Para obter 100 possibilidades (de 1 a 100), usamos nextInt(100) que gera [0, 99].
            // Adicionamos 1 para deslocar o intervalo para [1, 100].
            int numeroAleatorio = geradorNumeros.nextInt(maximoDesejado) + minimoDesejado;
            System.out.println(numeroAleatorio);
        }
    }
}

Ao executar este código, você observará uma sequência de números que variam entre 1 e 100, podendo incluir os valores extremos.

A Fórmula Generalizada para Qualquer Intervalo [min, max]

A abordagem de adicionar um valor para deslocar o intervalo pode ser generalizada. Para gerar um número aleatório N em um intervalo inclusivo [min, max], precisamos considerar dois aspectos:

1. A quantidade de possibilidades: O número total de inteiros no intervalo [min, max] é dado por max - min + 1. Este será o argumento para o método nextInt().
2. O deslocamento (offset): O valor mínimo do intervalo (min) atua como o deslocamento para garantir que o número gerado comece no ponto correto.

Combinando esses dois concietos, a fórmula universal para gerar um número aleatório em [min, max] em Java é:

int numeroAleatorio = randomInstance.nextInt(max - min + 1) + min;

Vamos aplicar essa fórmula a alguns cenários práticos:

• Para gerar um número de dois dígitos (intervalo [10, 99]):
  • min = 10, max = 99
  • Possibilidades: 99 - 10 + 1 = 90
  • Fórmula: randomInstance.nextInt(90) + 10;
• Para gerar um número de três dígitos (intervalo [100, 999]):
  • min = 100, max = 999
  • Possibilidades: 999 - 100 + 1 = 900
  • Fórmula: randomInstance.nextInt(900) + 100;
• Para gerar um número em um intervalo arbitrário [64, 128]:
  • min = 64, max = 128
  • Possibilidades: 128 - 64 + 1 = 65
  • Fórmula: randomInstance.nextInt(65) + 64;

Exemplo Completo Utilizando a Fórmula Generalizada

O seguinte programa demonstra o uso da fórmula em uma função auxiliar para gerar números em diferentes intervalos:

import java.util.Random;

public class GeradorIntervaloFlexivel {

    /**
     * Gera um número inteiro aleatório dentro de um intervalo inclusivo [min, max].
     *
     * @param gerador A instância de Random a ser usada.
     * @param min     O limite inferior do intervalo (inclusive).
     * @param max     O limite superior do intervalo (inclusive).
     * @return Um número inteiro aleatório entre min e max.
     * @throws IllegalArgumentException Se o valor mínimo for maior que o valor máximo.
     */
    public static int gerarNumeroNoIntervalo(Random gerador, int min, int max) {
        if (min > max) {
            throw new IllegalArgumentException("O valor mínimo não pode ser maior que o valor máximo.");
        }
        // O argumento de nextInt é o 'bound', que é exclusivo.
        // Precisamos de (max - min + 1) possibilidades para cobrir o intervalo inclusivo.
        // Adicionar 'min' desloca o resultado para que ele comece no limite inferior desejado.
        return gerador.nextInt(max - min + 1) + min;
    }

    public static void main(String[] args) {
        Random motorAleatorio = new Random();

        // Exemplo 1: Números de dois dígitos [10, 99]
        int minDoisDigitos = 10;
        int maxDoisDigitos = 99;
        System.out.println("\nGerando 5 números de dois dígitos (" + minDoisDigitos + "-" + maxDoisDigitos + "):");
        for (int i = 0; i < 5; i++) {
            System.out.println(gerarNumeroNoIntervalo(motorAleatorio, minDoisDigitos, maxDoisDigitos));
        }

        // Exemplo 2: Números de três dígitos [100, 999]
        int minTresDigitos = 100;
        int maxTresDigitos = 999;
        System.out.println("\nGerando 5 números de três dígitos (" + minTresDigitos + "-" + maxTresDigitos + "):");
        for (int i = 0; i < 5; i++) {
            System.out.println(gerarNumeroNoIntervalo(motorAleatorio, minTresDigitos, maxTresDigitos));
        }

        // Exemplo 3: Intervalo arbitrário [64, 128]
        int minArbitrario = 64;
        int maxArbitrario = 128;
        System.out.println("\nGerando 5 números no intervalo [" + minArbitrario + ", " + maxArbitrario + "]:");
        for (int i = 0; i < 5; i++) {
            System.out.println(gerarNumeroNoIntervalo(motorAleatorio, minArbitrario, maxArbitrario));
        }
    }
}