TOC

Java - Aléatoire Long, Float, Integer et Double

Java - Aléatoire Long, Float, Integer et Double

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

Cet article fait partie dethe “Java – Back to Basic” series ici par exemple.

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. Random Long avec Java simple

Ensuite, voyons comment créer 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 œ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 limite: 

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

Comme vous pouvez le voir, il 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

Next - 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 Commons Math

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

Maintenant, passons à 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 float 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 Commons Math

Maintenant - un nombre 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 Commons Math

En plus d'une valeur double 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 pertinents illustrant la manière de générer des valeurs non bornées et des valeurs bornées pour les primitives numériques les plus courantes en Java.

9. Conclusion

Ce didacticiel montre comment générer des nombres aléatoires liés ou non liés à l’aide de techniques et de bibliothèques différentes.

Comme toujours, l'implémentation de tous ces exemples et extraits de code peut être trouvée dans lesGitHub project. Ceci est un projet basé sur Maven, il devrait donc être facile à importer et à exécuter.

Related