Java - Random Long, Float, Integer et Double

Ce tutoriel rapide illustrera comment générer une longue première en utilisant Java pur et en utilisant la bibliothèque Apache Commons Math.

Cet article fait partie de la série «Java - Back to Basic» ici sur Baeldung.

1. Générer un long sans limite

Commençons par générer un Long:

@Test public void givenUsingPlainJava_whenGeneratingRandomLongUnbounded_thenCorrect() { long generatedLong = new Random().nextLong(); }

2. Générer un long dans une plage

2.1. Aléatoire long avec Java simple

Ensuite - regardons la création d'un Long borné aléatoire - c'est-à-dire une valeur Long dans une plage ou un intervalle donné:

@Test public void givenUsingPlainJava_whenGeneratingRandomLongBounded_thenCorrect() { long leftLimit = 1L; long rightLimit = 10L; long generatedLong = leftLimit + (long) (Math.random() * (rightLimit - leftLimit)); }

2.2. Random Long avec Apache Commons Math

Jetons un coup d'œil à la génération du Long aléatoire avec une API plus propre et Commons Math:

@Test public void givenUsingApacheCommons_whenGeneratingRandomLongBounded_thenCorrect() { long leftLimit = 10L; long rightLimit = 100L; long generatedLong = new RandomDataGenerator().nextLong(leftLimit, rightLimit); }

3. Générer un entier non borné

Passons directement à la génération d'un entier aléatoire sans limites:

@Test public void givenUsingPlainJava_whenGeneratingRandomIntegerUnbounded_thenCorrect() { int generatedInteger = new Random().nextInt(); }

Comme vous pouvez le voir, c'est assez proche de générer un long.

4. Générer un entier dans une plage

4.1. Entier aléatoire avec Java brut

Suivant - un entier aléatoire dans une plage donnée:

@Test public void givenUsingPlainJava_whenGeneratingRandomIntegerBounded_thenCorrect() { int leftLimit = 1; int rightLimit = 10; int generatedInteger = leftLimit + (int) (new Random().nextFloat() * (rightLimit - leftLimit)); }

4.2. Entier aléatoire avec mathématiques communes

Et la même chose avec Common Math:

@Test public void givenUsingApache_whenGeneratingRandomIntegerBounded_thenCorrect() { int leftLimit = 1; int rightLimit = 10; int generatedInteger = new RandomDataGenerator().nextInt(leftLimit, rightLimit); }

5. Générer un flotteur sans limite

Passons maintenant à la génération de flottants aléatoires - d'abord illimités:

@Test public void givenUsingPlainJava_whenGeneratingRandomFloatUnbouned_thenCorrect() { float generatedFloat = new Random().nextFloat(); }

6. Générer un flotteur dans une plage

6.1. Flotteur aléatoire avec Java simple

Et un flotteur aléatoire borné:

@Test public void givenUsingPlainJava_whenGeneratingRandomFloatBouned_thenCorrect() { float leftLimit = 1F; float rightLimit = 10F; float generatedFloat = leftLimit + new Random().nextFloat() * (rightLimit - leftLimit); }

6.2. Flottant aléatoire avec mathématiques communes

Maintenant - un flottant aléatoire borné avec 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. Générer un double sans limite

7.1. Double aléatoire non borné avec Java simple

Enfin - nous allons générer des valeurs doubles aléatoires - d'abord, avec l'API Java Math:

@Test public void givenUsingPlainJava_whenGeneratingRandomDoubleUnbounded_thenCorrect() { double generatedDouble = Math.random(); }

7.2. Double aléatoire non borné avec mathématiques communes

Ainsi qu'une double valeur aléatoire avec la bibliothèque Apache Commons Math:

@Test public void givenUsingApache_whenGeneratingRandomDoubleUnbounded_thenCorrect() { double generatedDouble = new RandomDataGenerator().getRandomGenerator().nextDouble(); }

8. Générer un double dans une plage

8.1. Double délimité aléatoire avec Java simple

Dans cet exemple, examinons un double aléatoire généré dans un intervalle - avec Java:

@Test public void givenUsingPlainJava_whenGeneratingRandomDoubleBounded_thenCorrect() { double leftLimit = 1D; double rightLimit = 10D; double generatedDouble = leftLimit + new Random().nextDouble() * (rightLimit - leftLimit); }

8.2. Double borné aléatoire avec mathématiques communes

Et enfin - un double aléatoire dans un intervalle, en utilisant la bibliothèque Apache Commons Math:

@Test public void givenUsingApache_whenGeneratingRandomDoubleBounded_thenCorrect() { double leftLimit = 1D; double rightLimit = 100D; double generatedDouble = new RandomDataGenerator().nextUniform(leftLimit, rightLimit); }

Et voilà - des exemples rapides et précis de la façon de générer à la fois des valeurs illimitées et limitées pour les primitives numériques les plus courantes en Java.

9. Conclusion

Ce tutoriel a illustré comment nous pouvions générer des nombres aléatoires liés ou non, en utilisant différentes techniques et bibliothèques.

Comme toujours, l'implémentation de tous ces exemples et extraits de code se trouve dans le projet GitHub. Il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter.