¿Qué es el generador de números aleatorios en Java?
Los números aleatorios se usan comúnmente para crear aplicaciones como Dados para un juego de mesa, un programa de juegos de azar, etc. Normalmente, la generación de números aleatorios lleva mucho tiempo. Pero, en el lenguaje de programación Java, esto se puede lograr de tres maneras. Se abordan en la sección siguiente Funciones del generador de números aleatorios en Java.
Funciones de generador de números aleatorios en Java
En Java, los números aleatorios se pueden generar de 3 formas:
- Método matemático aleatorio
- clase java.util.Random
- Clase ThreadLocalRandom
1. Método Math.random ()
La clase de Matemáticas de Java ofrece varios métodos para trabajar en cálculos como logaritmos, promedio, exponenciación, etc. random () es uno de los métodos entre ellos que devuelve un valor doble positivo dentro del rango de 0.0 y 1.0 donde 0.0 es inclusivo y 1.0 es exclusivo. Este método se puede usar con o sin usar parámetros. Si se proporcionan parámetros, el número aleatorio generado estará dentro del rango del parámetro dado.
Ejemplo 1
Código:
public class RandomNumber (
double num; //Declare a variable num
//Method which generates a random number
public double randnum()
(
num=Math.random();
return num;
)
// Main Method of a program
public static void main(String() args) (
//Printing a random number
System.out.println("Random Number generated inside main method: "+Math.random());
//Create an object of the class RandomNumber
RandomNumber randomobj=new RandomNumber();
//Store the return value obtained from randnum method in a variable randomval
double randomval=randomobj.randnum();
//Printing the random number stored in variable randomval
System.out.println("Random Number generated inside randomnumber method: "+randomval);
)
)
Salida:
En el ejemplo anterior, el número aleatorio se genera usando el método Math.random () de dos maneras: aplicándolo directamente dentro del método principal y llamando a un método que contiene Math.random () usando el objeto. Como se mencionó en la explicación anterior, podemos ver que se generan 2 números aleatorios dentro del rango de 0.0 y 1.0.
Para generar un número aleatorio dentro del rango de parámetros, la expresión general utilizada se menciona a continuación:
Math.random () * ((maxvalue - minvalue) +1) + minvalue
Ejemplo # 2
Donde maxvalue es el límite superior del rango y el valor min es el límite inferior del rango. Por ejemplo, para generar un número aleatorio entre 10 y 20, establezca el valor máximo como 20 y el valor mínimo como 10.
Código:
public class RandomNumParameters (
public double randomnum(double x, double y)//max value-y, min value-x
(
double z =(Math.random()*((yx)+1)+x); //Formula for random number generation within a range
return z;
)
public static void main(String() args)
(
RandomNumParameters ran=new RandomNumParameters(); //Create instance for the class RandomNumParameters
double num=ran.randomnum(3.0, 10.0); //Call the Method
System.out.println("Random number generated within the range of 3 and 10: "+num );
) )
Salida:
2. Clase java.util.Random
La clase Java.util.Random genera números aleatorios de diferentes tipos de datos como flotante, largo, entero, doble, booleano, etc. También es posible pasar el rango de números como argumentos para que se genere un número aleatorio dentro de ese rango . Para utilizar esta clase, se debe importar la clase Random de java.util (java.util.Random). Una vez que se importa esta clase, cree una instancia y llame a los métodos como next long (), nextInt (), etc., usando esa instancia.
Ejemplo 1
Código:
//Java program to generate Random numbers using Random class
package Sample;
import java.util.Random; //import Random Class
public class RandomNum (
public static void main(String() args) (
Random rand=new Random(); //Create instance of Random class
double randomnum=rand.nextDouble(); //Assign the Random Double value in randomnum variable
System.out.println("Random Double value: "+ randomnum);
)
)
Salida:
En el programa anterior, se genera un valor doble aleatorio utilizando el método nextDouble ().
3. clase ThreadLocalRandom
La clase ThreadLocalRandom es un tipo especializado de clase aleatoria que se introduce en Java versión 1.7. ThreadLocalRandom.current (). NextInt () es uno de los métodos comunes que se utiliza para generar números aleatorios. Normalmente se usa en aplicaciones de subprocesos múltiples.
Ejemplo 1
Código:
//Java Program to generate random numbers using ThreadLocalRandom Class
import java.util.concurrent.ThreadLocalRandom;
public class RandomNumThread (
public static void main(String() args) (
//print a random double
System.out.println("Random Double value using ThreadLocalRandom: "+ThreadLocalRandom.current().nextDouble());
)
)
Salida:
Generación de enteros
Se pueden generar enteros aleatorios usando la clase ThreadLocalRandom y la clase Random. En ambos casos, un método nextInt () se usa para lo mismo:
Ejemplo 1
Código:
//Java program to generate Random integer numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomInteger (
public static void main(String() args) (
Random rnd=new Random(); //Create instance of Random class
int randomnum1=rnd.nextInt(); //Random Integer value using Random Class
int randomnum2=rnd.nextInt(30); //Random Integer value within the range of 30
int randomnum3= ThreadLocalRandom.current().nextInt(); //Random Integer value using ThreadLocalRandom Class
System.out.println("Random Integer value using Random Class: "+ randomnum1);
System.out.println("Random Integer value within the range of 30: "+ randomnum2);
System.out.println("Random Integer value using ThreadLocalRandom Class: "+ randomnum3);
)
)
Salida:
En el ejemplo anterior, se generan tres números de tipo entero aleatorio donde uno de los métodos nextInt () tiene 30 como argumento. Entonces, al generar un número aleatorio, 30 se establecerá como límite superior y cero (límite inferior predeterminado) se establecerá como límite inferior.
Generando números de coma flotante
Similar a la generación de números enteros, los números de punto flotante pueden generarse usando un método nextFloat (). Este método se puede usar tanto en la clase aleatoria como en la clase ThreadLocalRandom:
Ejemplo 1
Código:
//Java program to generate Random Float numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomFloat (
public static void main(String() args) (
Random rnd=new Random(); //Create instance of Random class
float randomnum1=rnd.nextFloat(); //Random Float value using Random Class
float randomnum2= ThreadLocalRandom.current().nextFloat(); //Random Float value using ThreadLocalRandom Class
System.out.println("Random float value using Random Class: "+ randomnum1);
System.out.println("Random float value using ThreadLocalRandom Class: "+ randomnum2);
)
)
Salida:
Conclusión
Java contiene una gran cantidad de funciones que se pueden usar en programas. Esto ayuda a reducir el tiempo de procesamiento y las líneas de código. La generación de números aleatorios es una tarea en la que podemos usar algunas de estas funciones. Este documento cubre los diferentes métodos para lograr esto.
Artículos recomendados
Esta es una guía para el generador de números aleatorios en Java. Aquí discutimos funciones en Java con ejemplos y dos generadores diferentes. También puede consultar nuestros otros artículos relacionados para obtener más información:
- Generador de números aleatorios en Python
- Generador de números aleatorios en C
- Generador de números aleatorios en R
- Recursion en Java
- Generador de números aleatorios en Matlab
- Generador de números aleatorios en C #
- Matrices en programación Java
- Generador de números aleatorios en JavaScript
- Generador de números aleatorios en PHP