Ya deberíamos saber cómo hacer que nuestros programas «escuchen» al usuario con Scanner. Ahora, vamos a darles un toque de «vida» e imprevisibilidad. ¿Cómo creamos un juego de dados si el resultado siempre es el mismo? ¿Cómo simulamos un sorteo? La respuesta está en la generación de números aleatorios. En Java, tenemos principalmente dos formas de hacerlo. Al igual que con Scanner, no necesitas entender la Programación Orientada a Objetos para usarlas. Vamos a tratarlas como dos herramientas distintas: una «utilidad rápida» y la otra como una «herramienta especializada».

1. El camino directo: Math.random() 🎯

Java nos ofrece una herramienta matemática integrada, Math.random(), que está siempre disponible, sin necesidad de importar nada.

¿Qué hace?

Math.random() es muy simple: devuelve un número decimal (double) aleatorio que es mayor o igual que 0.0 y estrictamente menor que 1.0.

Rango: 0.0 \le \text{valor} < 1.0

public class PruebaRandom {
    public static void main(String[] args) {
        // Devuelve un número como 0.4732..., 0.0012..., 0.9823...
        double aleatorio = Math.random();
        System.out.println("Número aleatorio: " + aleatorio);
    }
}

¿Cómo lo hacemos útil? (La fórmula para escalar)

Casi nunca queremos un decimal entre 0 y 1. Lo que solemos querer es, por ejemplo, un número entero para simular un dado (del 1 al 6). Para lograrlo, necesitamos una «fórmula mágica» que transforme ese rango.

Fórmula general: (int) (Math.random() * (max - min + 1)) + min

Para nuestro dado (donde min=1 y max=6):

// Math.random()            -> 0.0 a 0.999...
// Math.random() * 6        -> 0.0 a 5.999...
// (int)(Math.random() * 6) -> 0, 1, 2, 3, 4, ó 5 (corta la parte decimal)
// ... + 1                  -> 1, 2, 3, 4, 5, ó 6

int dado = (int) (Math.random() * 6) + 1;
System.out.println("Has sacado un: " + dado);

• Ventaja: Es rápido y no requiere importar nada.
• Inconveniente: La fórmula para escalar es aparatosa, fácil de olvidar y propensa a errores (el famoso «+1» o no).

2. La herramienta especializada: la clase Random 🛠️

Aquí es donde las cosas se ponen interesantes. Java nos ofrece una herramienta mucho más potente y clara para generar aleatoriedad. Al igual que Scanner, requiere dos pasos: importarla e inicializarla.

2.1. Importar la herramienta

Al principio de tu archivo .java, junto a tus otros import:

Java

import java.util.Random; // Le decimos a Java dónde está la herramienta Random
import java.util.Scanner; // (Ya la teníamos de antes)

2.2. Inicializar la herramienta

Dentro de tu main, creamos nuestro «generador». De nuevo, por ahora trata esta línea como una «fórmula de inicialización» para encender la máquina:

public static void main(String[] args) {
    // Fórmula para crear nuestro generador de números aleatorios
    Random generador = new Random();
    
    // A partir de aquí, 'generador' es nuestra herramienta
}

2.3. Usando el generador (¡Mucho más fácil!)

Esta herramienta generador tiene métodos mucho más directos. El más importante es nextInt(bound):

• generador.nextInt(int bound): Devuelve un número entero aleatorio entre 0 (incluido) y bound (excluido).

¡Veamos qué fácil es simular nuestro dado ahora!

// ... (después de inicializar el 'generador')

// nextInt(6) nos da un número del 0 al 5
// (0, 1, 2, 3, 4, ó 5)
// Le sumamos 1 para obtener el rango 1-6
int dado = generador.nextInt(6) + 1;

System.out.println("Has sacado un: " + dado);

Esta herramienta también nos da otros métodos útiles:

• generador.nextInt(): Devuelve cualquier número entero (positivo o negativo).
• generador.nextDouble(): Devuelve un double (igual que Math.random()).
• generador.nextBoolean(): Devuelve true o false aleatoriamente. ¡Perfecto para un «cara o cruz»!
• generador.nextInt(init, bound): disponible desde Java 17. Devuelve un número aleatorio en el rango init \le \text{valor} < bound

boolean moneda = generador.nextBoolean();
if (moneda) {
    System.out.println("¡Cara!");
} else {
    System.out.println("¡Cruz!");
}

3. Math.random() vs. Random: ¿Cuál uso?

Aquí tienes una comparativa rápida:

Veredicto y conveniencia 🏆

Aunque Math.random() puede parecer más rápido para un solo uso, la fórmula de escalado es confusa.

Mi recomendación: Acostúmbrate a usar siempre la clase Random.

Cuesta solo dos líneas más (el import y la inicialización), pero a cambio obtienes un código muchísimo más legible y potente. El método nextInt(bound) es claro, directo y te permite generar enteros en cualquier rango de forma muy intuitiva.

• Usa Math.random() si: Solo quieres un decimal rápido entre 0 y 1 y no vas a hacer nada más.
• Usa Random si: Vas a generar enteros (¡casi siempre!), necesitas simular dados, loterías, o quieres generar múltiples números aleatorios en tu programa. Siempre será más legible.