Usando Math.random en Java

Math.random()

El método Math.random() es un método estático que genera un valor double pseudoaleatorio mayor o igual a 0.0 y menor que 1.0. Forma parte de la clase Math, que proporciona varios métodos para realizar operaciones numéricas básicas como exponenciación, logaritmos y operaciones trigonométricas. La simplicidad de Math.random() lo hace altamente accesible para generar números pseudoaleatorios rápidamente.

public class Main {
    public static void main(String[] args) {
        // Generate a random double value between 0.0 and 1.0
        double value = Math.random();
        System.out.println("Random double value: " + value);
    }
}

public class Main {
    public static void main(String[] args) {
        // Generate a random double value between 0.0 and 1.0
        double value = Math.random();
        System.out.println("Random double value: " + value);
    }
}

Este ejemplo demuestra cómo generar valores double aleatorios e imprimirlos en la consola.

La clase aleatoria

Para requisitos más diversos, como generar enteros, booleanos o números de punto flotante aleatorios dentro de un rango especificado, la clase Random en el paquete java.util es más adecuada. Requiere crear una instancia de la clase Random, seguida de llamar a uno de sus métodos para generar un número aleatorio.

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        // Create a Random object
        Random random = new Random();
        // Generates a random integer from 0 to 9
        int randomInt = random.nextInt(10);
        System.out.println("Random integer: " + randomInt);
    }
}

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        // Create a Random object
        Random random = new Random();
        // Generates a random integer from 0 to 9
        int randomInt = random.nextInt(10);
        System.out.println("Random integer: " + randomInt);
    }
}

Este fragmento de código crea un objeto Random y lo utiliza para generar un número entero aleatorio entre 0 y 9.

Simplicidad y facilidad de uso

Math.random() es increíblemente sencillo, no requiere instanciación de objetos ni configuraciones complejas, lo que lo hace ideal para principiantes o casos de uso donde solo se necesita un valor double aleatorio único.

Flexibilidad y control

La clase Random ofrece un rango más amplio de métodos para generar números aleatorios, incluidos nextInt(), nextDouble(), nextFloat(), nextLong() y nextBoolean(), proporcionando mayor flexibilidad y control sobre los números aleatorios generados.

Reproducibilidad

Usando un valor semilla con la clase Random, es posible producir una secuencia predecible de números pseudoaleatorios, lo cual puede ser extremadamente útil para la depuración o para aplicaciones donde se desea un cierto grado de predictibilidad.

Desarrollo de juegos: Tirar un dado

public class Main {
    public static void main(String[] args) {
        int max = 6; // Maximum face value of the die
        // Generate a random integer between 1 and 6
        int roll = (int) (Math.random() * max) + 1;
        System.out.println("You rolled a: " + roll);
    }
}

public class Main {
    public static void main(String[] args) {
        int max = 6; // Maximum face value of the die
        // Generate a random integer between 1 and 6
        int roll = (int) (Math.random() * max) + 1;
        System.out.println("You rolled a: " + roll);
    }
}

Ejemplo de Salida en Consola: Tiraste un: 6

Este ejemplo simula el lanzamiento de un dado de seis caras generando un entero aleatorio entre 1 y 6. Demuestra cómo usar Math.random() para generar números dentro de un rango específico multiplicando el resultado por el valor máximo y sumando uno para cambiar el rango de 0-5 a 1-6.

Simulación: Generación de condiciones meteorológicas

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        // Generate a random temperature from -10 to 20 degrees Celsius
        int temp = random.nextInt(31) - 10;
        // Generate a random boolean to indicate raining condition
        boolean raining = random.nextBoolean();
        System.out.println("Today's temperature is: " + temp + "C, and it is " + (raining ? "raining" : "not raining"));
    }
}

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        // Generate a random temperature from -10 to 20 degrees Celsius
        int temp = random.nextInt(31) - 10;
        // Generate a random boolean to indicate raining condition
        boolean raining = random.nextBoolean();
        System.out.println("Today's temperature is: " + temp + "C, and it is " + (raining ? "raining" : "not raining"));
    }
}

Ejemplo de Salida en Consola: La temperatura de hoy es: 8C, y está lloviendo

Este fragmento simula condiciones climáticas generando una temperatura aleatoria dentro de un rango especificado y un valor booleano para indicar si está lloviendo. Ilustra el uso de la clase Random para generar valores tanto enteros como booleanos.

Aprendizaje automático: Barajando datos

import java.util.Collections;
import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Initialize an ArrayList with integers
        ArrayList<Integer> data = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        // Shuffle the list to randomize element order
        Collections.shuffle(data);
        System.out.println("Shuffled data: " + data);
    }
}

import java.util.Collections;
import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Initialize an ArrayList with integers
        ArrayList<Integer> data = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
        // Shuffle the list to randomize element order
        Collections.shuffle(data);
        System.out.println("Shuffled data: " + data);
    }
}

Ejemplo de Salida en Consola: Datos mezclados: [5, 3, 1, 4, 2]

Aunque no usa directamente Math.random() o la clase Random, este ejemplo demuestra cómo mezclar una lista de enteros, una operación común en preparación de datos para algoritmos de aprendizaje automático. Collections.shuffle() utiliza internamente Random para mezclar los elementos.

Ejemplo

package ironpdf;

import com.ironsoftware.ironpdf.*;
import java.awt.print.PrinterException;
import java.io.IOException;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) throws IOException, PrinterException {
        // Set license key for IronPDF
        License.setLicenseKey("Key");
        // Generate a random number between 0 and 99
        int randomNumber = (int) (Math.random() * 100);
        // Create HTML content, embedding the random number
        String htmlContent = "<html><body><h1>Random Number</h1><p>" + randomNumber + "</p></body></html>";
        // Render HTML content to PDF
        PdfDocument pdf = PdfDocument.renderHtmlAsPdf(htmlContent);
        // Save the PDF to a specified path
        pdf.saveAs(Paths.get("f:\\IronPdf\\random.pdf"));
    }
}

package ironpdf;

import com.ironsoftware.ironpdf.*;
import java.awt.print.PrinterException;
import java.io.IOException;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) throws IOException, PrinterException {
        // Set license key for IronPDF
        License.setLicenseKey("Key");
        // Generate a random number between 0 and 99
        int randomNumber = (int) (Math.random() * 100);
        // Create HTML content, embedding the random number
        String htmlContent = "<html><body><h1>Random Number</h1><p>" + randomNumber + "</p></body></html>";
        // Render HTML content to PDF
        PdfDocument pdf = PdfDocument.renderHtmlAsPdf(htmlContent);
        // Save the PDF to a specified path
        pdf.saveAs(Paths.get("f:\\IronPdf\\random.pdf"));
    }
}