Este tutorial rápido ilustrará cómo generar un primero largo usando Java simple y usando la biblioteca Apache Commons Math.
Este artículo es parte de la serie "Java - Back to Basic" aquí en Baeldung.
1. Genere un largo ilimitado
Comencemos generando un Long:
@Test public void givenUsingPlainJava_whenGeneratingRandomLongUnbounded_thenCorrect() { long generatedLong = new Random().nextLong(); }2. Genere un largo dentro de un rango
2.1. Largo aleatorio con Java simple
A continuación, veamos cómo crear un Long limitado aleatorio, es decir, un valor Long dentro de un rango o intervalo dado:
@Test public void givenUsingPlainJava_whenGeneratingRandomLongBounded_thenCorrect() { long leftLimit = 1L; long rightLimit = 10L; long generatedLong = leftLimit + (long) (Math.random() * (rightLimit - leftLimit)); }2.2. Random Long con Apache Commons Math
Echemos un vistazo a la generación de Long aleatorio con una API más limpia y Commons Math:
@Test public void givenUsingApacheCommons_whenGeneratingRandomLongBounded_thenCorrect() { long leftLimit = 10L; long rightLimit = 100L; long generatedLong = new RandomDataGenerator().nextLong(leftLimit, rightLimit); }3. Genere un número entero ilimitado
Pasemos a la generación de un entero aleatorio sin límites:
@Test public void givenUsingPlainJava_whenGeneratingRandomIntegerUnbounded_thenCorrect() { int generatedInteger = new Random().nextInt(); }Como puede ver, está bastante cerca de generar un long.
4. Genere un número entero dentro de un rango
4.1. Entero aleatorio con Java simple
Siguiente: un número entero aleatorio dentro de un rango determinado:
@Test public void givenUsingPlainJava_whenGeneratingRandomIntegerBounded_thenCorrect() { int leftLimit = 1; int rightLimit = 10; int generatedInteger = leftLimit + (int) (new Random().nextFloat() * (rightLimit - leftLimit)); }4.2. Entero aleatorio con matemáticas comunes
Y lo mismo con Common Math:
@Test public void givenUsingApache_whenGeneratingRandomIntegerBounded_thenCorrect() { int leftLimit = 1; int rightLimit = 10; int generatedInteger = new RandomDataGenerator().nextInt(leftLimit, rightLimit); }5. Genere un flotador ilimitado
Ahora, repasemos la generación de flotadores aleatorios, primero sin límites:
@Test public void givenUsingPlainJava_whenGeneratingRandomFloatUnbouned_thenCorrect() { float generatedFloat = new Random().nextFloat(); }6. Genere un flotador dentro de un rango
6.1. Flotación aleatoria con Java simple
Y un flotador aleatorio acotado:
@Test public void givenUsingPlainJava_whenGeneratingRandomFloatBouned_thenCorrect() { float leftLimit = 1F; float rightLimit = 10F; float generatedFloat = leftLimit + new Random().nextFloat() * (rightLimit - leftLimit); }6.2. Flotación aleatoria con matemáticas comunes
Ahora, un flotante aleatorio acotado con Commons Math:
@Test public void givenUsingApache_whenGeneratingRandomFloatBounded_thenCorrect() { float leftLimit = 1F; float rightLimit = 10F; float randomFloat = new RandomDataGenerator().getRandomGenerator().nextFloat(); float generatedFloat = leftLimit + randomFloat * (rightLimit - leftLimit); }7. Genera un doble ilimitado
7.1. Doble aleatorio ilimitado con Java simple
Finalmente, vamos a generar valores dobles aleatorios, primero, con la API de Java Math:
@Test public void givenUsingPlainJava_whenGeneratingRandomDoubleUnbounded_thenCorrect() { double generatedDouble = Math.random(); }7.2. Doble aleatorio ilimitado con matemáticas comunes
Además de un valor doble aleatorio con la biblioteca Apache Commons Math:
@Test public void givenUsingApache_whenGeneratingRandomDoubleUnbounded_thenCorrect() { double generatedDouble = new RandomDataGenerator().getRandomGenerator().nextDouble(); }8. Genere un doble dentro de un rango
8.1. Doble delimitado aleatorio con Java simple
En este ejemplo, echemos un vistazo a un doble aleatorio generado dentro de un intervalo, con Java:
@Test public void givenUsingPlainJava_whenGeneratingRandomDoubleBounded_thenCorrect() { double leftLimit = 1D; double rightLimit = 10D; double generatedDouble = leftLimit + new Random().nextDouble() * (rightLimit - leftLimit); }8.2. Doble delimitado aleatorio con matemáticas comunes
Y, por último, un doble aleatorio dentro de un intervalo, utilizando la biblioteca Apache Commons Math:
@Test public void givenUsingApache_whenGeneratingRandomDoubleBounded_thenCorrect() { double leftLimit = 1D; double rightLimit = 100D; double generatedDouble = new RandomDataGenerator().nextUniform(leftLimit, rightLimit); }Y ahí lo tiene: ejemplos rápidos y concretos de cómo generar valores ilimitados y limitados para las primitivas numéricas más comunes en Java.
9. Conclusión
Este tutorial ilustró cómo podríamos generar números aleatorios, ya sea vinculados o no, utilizando diferentes técnicas y bibliotecas.
Como siempre, la implementación de todos estos ejemplos y fragmentos se puede encontrar en el proyecto GitHub. Este es un proyecto basado en Maven, por lo que debería ser fácil de importar y ejecutar.