Générer des valeurs doubles aléatoires entre 0 et 1 en Java

1. Générer des valeurs doubles aléatoires entre 0 et 1 à l’aide de Math.random() en Java
2. Générer des valeurs doubles aléatoires entre 0 et 1 à l’aide de Random().nextDouble() en Java
3. Générer des valeurs doubles aléatoires entre 0 et 1 à l’aide de ThreadLocalRandom.current().nextDouble() en Java

Cet article présentera trois méthodes pour générer des valeurs aléatoires entre 0 et 1 de type primitif double. Pour prouver le caractère aléatoire des valeurs générées, nous utiliserons une boucle pour générer dix valeurs aléatoires de type double entre 0 et 1.

Générer des valeurs doubles aléatoires entre 0 et 1 à l’aide de Math.random() en Java

La classe Math peut être utilisée pour effectuer diverses opérations mathématiques. Nous pouvons également utiliser cette classe pour générer des nombres aléatoires. Math.random() est la fonction statique qui renvoie des nombres aléatoires entre 0 et 1. Ici, 0 inclut les valeurs générées, tandis que 1 est toujours exclusif.

Dans l’exemple suivant, nous utilisons Math.random() pour générer des valeurs aléatoires de type double. Dans la sortie, nous pouvons voir que les valeurs sont toutes aléatoires.

public class RandomDouble {
  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      double randomDbl = Math.random();

      System.out.println(randomDbl);
    }
  }
}

Production:

0.9537872648347154
0.2863804438195172
0.5815339629441948
0.7734677312115609
0.021051510563543485
0.9064133490694901
0.6833468691871607
0.30655711217738246
0.2730784326888416
0.6804778782692341

Générer des valeurs doubles aléatoires entre 0 et 1 à l’aide de Random().nextDouble() en Java

Une autre méthode qui peut générer des nombres aléatoires entre 0 et 1 est nextDouble(), une partie de la classe java.util.Random. Lorsque nous appelons nextDouble() avec l’objet de la classe Random, cela renvoie une valeur aléatoire comprise entre 0 et 1, comme nous l’avons vu dans l’exemple précédent.

On dit que cette méthode est plus efficace que Math.random().

import java.util.Random;

public class RandomDouble {
  public static void main(String[] args) {
    Random randomObj = new Random();

    for (int i = 0; i < 10; i++) {
      double randomDbl = randomObj.nextDouble();

      System.out.println(randomDbl);
    }
  }
}

Production:

0.240017494934622
0.08331956619499614
0.4359524465181911
0.5291811081068774
0.38193057731688373
0.6969527822622924
0.5436002348156281
0.32176862575520415
0.07327708002828293
0.9005635171231344

Générer des valeurs doubles aléatoires entre 0 et 1 à l’aide de ThreadLocalRandom.current().nextDouble() en Java

Les deux techniques que nous avons vues dans ce didacticiel ne sont pas efficaces pour les systèmes multithreads et peuvent entraîner de mauvaises performances. Cela arrive parce que lorsque nous générons des nombres aléatoires à l’aide de la classe Random, tous les threads partagent la même instance, ce qui signifie que lorsqu’un changement se produit sur un thread, tous les autres threads sont également exécutés.

Pour résoudre ce problème, Java a introduit ThreadLocalRandom dans la mise à jour JDK 7. C’est une classe qui s’exécute uniquement sur le thread actuel, ce qui permet d’obtenir de meilleures performances dans un environnement avec plusieurs threads.

Dans l’exemple ci-dessous, nous appelons le nextDouble() qui génère des valeurs doubles aléatoires avec ThreadLocalRandom.current(), et il renvoie une génération aléatoire d’une valeur double entre 0 et 1.

import java.util.concurrent.ThreadLocalRandom;

public class RandomDouble {
  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      double randomDbl = ThreadLocalRandom.current().nextDouble();

      System.out.println(randomDbl);
    }
  }
}

Production:

0.9717084711770174
0.8977374014983726
0.2744375247405819
0.2866498720386894
0.6118970047667582
0.7441044456568308
0.21043457873690274
0.08985457420563114
0.86748682220748
0.18952106607144148