Usando Math.random en Java

Math.random()

El método Math.random() es un método estático que genera un valor pseudoaleatorio double 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 trigonometría. La simplicidad de Math.random() hace que sea muy accesible 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 aleatorios double e imprimirlos en la consola.

La clase Random

Para requisitos más diversos, como generar números enteros aleatorios, booleanos o de punto flotante dentro de un rango específico, la clase Random del paquete java.util es más adecuada. Requiere crear una instancia de la clase Random, seguido 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 entero aleatorio entre 0 y 9.

Simplicidad y facilidad de uso

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

Flexibilidad y control

La clase Random ofrece una gama más amplia de métodos para generar números aleatorios, incluidos nextInt(), nextDouble(), nextFloat(), nextLong() y nextBoolean(), lo que proporciona mayor flexibilidad y control sobre los números aleatorios generados.

Reproducibilidad

Al utilizar un valor semilla con la clase Random, es posible producir una secuencia predecible de números pseudoaleatorios, lo que puede ser extremadamente útil para la depuración o para aplicaciones donde es deseable un cierto grado de previsibilidad.

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 número entero aleatorio entre 1 y 6. Muestra 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 enteros y 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]

Si bien no se utiliza directamente Math.random() o la clase Random, este ejemplo demuestra cómo mezclar una lista de números enteros, una operación común en la preparación de datos para algoritmos de aprendizaje automático. Collections.shuffle() utiliza internamente Random para mezclar 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"));
    }
}