En Java programación, a menudo necesitamos generar números aleatorios mientras desarrollamos aplicaciones. Muchas aplicaciones tienen la función de generar números aleatoriamente , como para verificar el usuario, muchas aplicaciones usan el OTP . El mejor ejemplo de números aleatorios son los dados. Porque cuando lo lanzamos, obtenemos un número aleatorio entre 1 y 6.

En esta sección aprenderemos qué es un número aleatorio y cómo generar números aleatorios en Java .

Número aleatorio

Los números aleatorios son los números que usan un gran conjunto de números y seleccionan un número usando el algoritmo matemático. Satisface las dos condiciones siguientes:

• Los valores generados se distribuyen uniformemente en un intervalo definido.
• Es imposible adivinar el valor futuro basándose en los valores actuales y pasados.

Generando números aleatorios en Java

En Java, existen tres formas de generar números aleatorios utilizando el método y las clases.

mecanografiado para cada uno

• Utilizando el aleatorio() Método
• Utilizando el aleatorio Clase
• Utilizando el HiloLocalAleatorio Clase
• Utilizando el enteros() Método (en Java 8)

Usando el método Math.random()

la java Matemáticas La clase tiene muchos métodos para diferentes operaciones matemáticas. Uno de ellos es el aleatorio() método. Es un estático método de la clase de Matemáticas. Podemos invocarlo directamente. Genera solo doble escriba un número aleatorio mayor o igual a 0,0 y menos de 1,0 . Antes de usar el método random(), debemos importar eljava.lang.Matemáticasclase.

Sintaxis:

 public static double random() 

No acepta ningún parámetro. Devuelve un doble pseudoaleatorio mayor o igual a 0,0 y menor que 1,0.

Creemos un programa que genere números aleatorios usando el método random().

RandomNumberExample1.java

 import java.lang.Math; public class RandomNumberExample1 { public static void main(String args[]) { // Generating random numbers System.out.println('1st Random Number: ' + Math.random()); System.out.println('2nd Random Number: ' + Math.random()); System.out.println('3rd Random Number: ' + Math.random()); System.out.println('4th Random Number: ' + Math.random()); } } 

Producción:

 1st Random Number: 0.17434160924512265 2nd Random Number: 0.4297410090709448 3rd Random Number: 0.4828656381344487 4th Random Number: 0.13267917059488898 

Recordar: Cada vez obtenemos una salida diferente cuando ejecutamos el programa. Su resultado puede diferir del resultado que se muestra arriba.

También podemos usar la siguiente fórmula si queremos generar un número aleatorio entre un rango específico.

 Math.random() * (max - min + 1) + min 

En la fórmula anterior, el valor mínimo es inclusivo mientras que el valor máximo es exclusivo.

Creemos un programa que genere números aleatorios entre 200 y 400.

RandomNumberExample2.java

 public class RandomNumberExample2 { public static void main( String args[] ) { int min = 200; int max = 400; //Generate random double value from 200 to 400 System.out.println('Random value of type double between '+min+' to '+max+ ':'); double a = Math.random()*(max-min+1)+min; System.out.println(a); //Generate random int value from 200 to 400 System.out.println('Random value of type int between '+min+' to '+max+ ':'); int b = (int)(Math.random()*(max-min+1)+min); System.out.println(b); } } 

Salida 1:

 Random value of type double between 200 to 400: 233.88329802655377 Random value of type int between 200 to 400: 329 

Salida 2:

 Random value of type double between 200 to 400: 254.8419979875385 Random value of type int between 200 to 400: 284 

Usando la clase aleatoria

Otra forma de generar un número aleatorio es utilizar el Java aleatorio clase deljava.utilpaquete. Genera un flujo de números pseudoaleatorios. Podemos generar un número aleatorio de cualquier tipo de datos, como entero, flotante, doble, booleano, largo. Si va a utilizar esta clase para generar números aleatorios, siga los pasos que se detallan a continuación:

• Primero, importa la clase.java.lang.Aleatorio.
• Crear un objeto de la clase Aleatoria.
• Invoque cualquiera de los siguientes métodos:
nextInt(int enlazado) siguienteInt() siguienteFlotar() siguienteDoble() siguienteLong() siguienteBooleano()

Todos los métodos anteriores devuelven el siguiente valor pseudoaleatorio distribuido homogéneamente (método correspondiente) de la secuencia de este generador de números aleatorios. El siguienteDoble() y siguienteFlotar() El método genera un valor aleatorio entre 0,0 y 1,0.

El nextInt(int enlazado) El método acepta un parámetro vinculado (superior) que debe ser positivo. Genera un número aleatorio en el rango de 0 a límite 1.

Creemos un programa que genere números aleatorios usando la clase Random.

RandomNumberExample3.java

 import java.util.Random; public class RandomNumberExample3 { public static void main(String args[]) { // creating an object of Random class Random random = new Random(); // Generates random integers 0 to 49 int x = random.nextInt(50); // Generates random integers 0 to 999 int y = random.nextInt(1000); // Prints random integer values System.out.println('Randomly Generated Integers Values'); System.out.println(x); System.out.println(y); // Generates Random doubles values double a = random.nextDouble(); double b = random.nextDouble(); // Prints random double values System.out.println('Randomly Generated Double Values'); System.out.println(a); System.out.println(b); // Generates Random float values float f=random.nextFloat(); float i=random.nextFloat(); // Prints random float values System.out.println('Randomly Generated Float Values'); System.out.println(f); System.out.println(i); // Generates Random Long values long p = random.nextLong(); long q = random.nextLong(); // Prints random long values System.out.println('Randomly Generated Long Values'); System.out.println(p); System.out.println(q); // Generates Random boolean values boolean m=random.nextBoolean(); boolean n=random.nextBoolean(); // Prints random boolean values System.out.println('Randomly Generated Boolean Values'); System.out.println(m); System.out.println(n); } } 

Producción:

 Randomly Generated Integers Values 23 767 Randomly Generated Double Values 0.37823814494212016 0.998058172671956 Randomly Generated Float Values 0.87804186 0.93880254 Randomly Generated Long Values -4974823544291679198 3650240138416076693 Randomly Generated Boolean Values false true 

Usando la clase ThreadLocalRandom

El HiloLocalAleatorio la clase se define enjava.util.concurrentepaquete. Se inicializa con una semilla generada internamente, igual que el generador aleatorio de la clase Math. No se puede modificar. Podemos utilizar esta clase de la siguiente manera:

 ThreadLocalRandom.current().nextX(...) 

Donde X es Int, Long, etc.

Nota: Es imposible compartir un ThreadLocalRandom con varios subprocesos accidentalmente.

Podemos generar un número aleatorio de cualquier tipo de datos, como entero, flotante, doble, booleano, largo. Si va a utilizar esta clase para generar números aleatorios, siga los pasos que se detallan a continuación:

• Primero, importe la clase usandojava.util.concurrent.ThreadLocalRandom.
• Invoque el método correspondiente para el que desea generar números aleatoriamente.
siguienteInt() siguienteDoble() siguienteLong() siguienteFlotar() siguienteBooleano()

Todos los métodos anteriores anulan el método correspondiente de la clase Random y devuelven el valor correspondiente.

nextInt(int enlazado) nextDouble(int enlazado) nextLong(int enlazado)

Los métodos anteriores analizan un parámetro. atado (superior) que debe ser positivo . Devuelve el valor correspondiente generado aleatoriamente entre 0 (inclusive) y el límite especificado (exclusivo). arroja Argumento ilegalExcepción si el límite es negativo.

nextInt(origen int, límite int) nextDouble(origen int, límite int) nextLong(origen int, límite int)

Los métodos anteriores analizan dos parámetros. origen y atado . El origen especifica el menor valor devuelto y el límite especifica el límite superior . Devuelve el valor correspondiente generado aleatoriamente entre el origen especificado (inclusive) y el límite (exclusivo). Además, lanza Argumento ilegalExcepción si el origen es mayor o igual que el límite.

Creemos un programa que genere números aleatorios usando el Clase ThreadLocalRandom .

RandomNumberExample4.java

 import java.util.concurrent.ThreadLocalRandom; public class RandomNumberExample4 { public static void main(String args[]) { // Generate random integers between 0 to 999 int a = ThreadLocalRandom.current().nextInt(); int b = ThreadLocalRandom.current().nextInt(); // Print random integer values System.out.println('Randomly Generated Integer Values:'); System.out.println(a); System.out.println(b); // Generate Random double values double c = ThreadLocalRandom.current().nextDouble(); double d = ThreadLocalRandom.current().nextDouble(); // Print random doubles System.out.println('Randomly Generated Double Values:'); System.out.println(c); System.out.println(d); // Generate random boolean values boolean e = ThreadLocalRandom.current().nextBoolean(); boolean f = ThreadLocalRandom.current().nextBoolean(); // Print random Booleans System.out.println('Randomly Generated Boolean Values:'); System.out.println(e); System.out.println(f); } } 

Salida 1:

 Randomly Generated Integer Values: 348534891 -1887936727 Randomly Generated Double Values: 0.15644440033119833 0.5242730752133399 Randomly Generated Boolean Values: true true 

Salida 2:

 Output 2: Randomly Generated Integer Values: 402755574 295398333 Randomly Generated Double Values: 0.4856461791062565 0.5148677091077654 Randomly Generated Boolean Values: false true 

Del mismo modo, podemos utilizar otros métodos de ThreadLocalRandomclase .

Generación de números aleatorios en Java 8

En Java 8, se ha agregado un nuevo método ints() al clase aleatoria . Debemos importar eljava.util.Aleatorioantes de utilizar el método.

enteros():

Los valores int pseudoaleatorios generaron lo mismo que llamar al método nextInt(). Devuelve un flujo ilimitado de valores int pseudoaleatorios.

ints (tamaño de flujo largo):

El método analiza un parámetro. Tamaño de la corriente de tipo largo. Especifica el número de valores que se generarán. Los valores int pseudoaleatorios generaron lo mismo que llamar al método nextInt(). También devuelve un flujo de valores int generados aleatoriamente. arroja Argumento de excepción ilegal si el tamaño del flujo es menor que cero.

ints (long streamSize, int randomNumberOrigin, int randomNumberBound):

Parámetros:

tamaño de la corriente:Número de valores a generar.OrigenNúmeroAleatorio:Origen de cada valor aleatoriolímite de número aleatorio:Límite de cada valor aleatorio

Devuelve una secuencia de valores int pseudoaleatorios con el origen y el límite especificados. arroja Argumento de excepción ilegal si:

• Tamaño del Stram<0< li>
• origen > = ligado

 ints(int randomNumberOrigin, int randomNumberBound): 

Parámetros:

Devuelve un flujo ilimitado de valores int pseudoaleatorios con el origen y el límite especificados. arroja Argumento de excepción ilegal si el origen es mayor o igual que el límite.

De manera similar, también podemos generar el flujo de tipos largos y dobles usando el pantalones largos() y dobles() método, respectivamente.

Creemos un programa que genere un flujo de números enteros usando el enteros() método de la clase aleatoria.

RandomNumberExample5.java

 import java.util.Random; public class RandomNumberExample5 { public static void main(String[] args) { randomInts(5); randomInts(9, 50, 90); //getStreamOfRandomInts(30, 50); } //method that generates a stream of integers having size 5 public static void randomInts(int num) { Random random = new Random(); random.ints(num).forEach(System.out::println); } //method that generates a stream of 9 integers between 50 to 90 public static void randomInts(int num, int origin, int bound) { Random random1 = new Random(); random1.ints(num, origin, bound).forEach(System.out::println); } } 

Salida 1:

 727900357 -1073118456 306279822 370327182 1366265119 65 75 75 88 76 75 56 86 85 

Salida 2:

 -1338107947 -1698771421 594232770 -1224937976 -1625069815 56 69 67 87 64 52 72 75 76