Générer un double aléatoire dans une plage

J'ai deux doubles comme le suivant

double min = 100;
double max = 101;

et avec un générateur aléatoire, je dois créer une double valeur entre la plage de min et max.

Random r = new Random();
r.nextDouble();

mais il n'y a rien ici où nous pouvons spécifier la plage.

Pour générer une valeur aléatoire entre rangeMinet rangeMax:

Random r = new Random();
double randomValue = rangeMin + (rangeMax - rangeMin) * r.nextDouble();

Cette question a été posée avant la sortie de Java 7, mais maintenant, il existe un autre moyen possible d'utiliser l'API Java 7 (et supérieur):

double random = ThreadLocalRandom.current().nextDouble(min, max);

nextDoublerenverra une valeur double pseudo-aléatoire entre le minimum (inclus) et le maximum (exclusif). Les limites ne sont pas nécessairement intet peuvent l'être double.

Utilisez ceci:

double start = 400;
double end = 402;
double random = new Random().nextDouble();
double result = start + (random * (end - start));
System.out.println(result);

ÉDITER:

new Random().nextDouble(): génère aléatoirement un nombre entre 0 et 1.

start: numéro de départ, pour décaler le numéro "vers la droite"

end - start: intervalle. Random vous donne de 0% à 100% de ce nombre, car random vous donne un nombre de 0 à 1.

EDIT 2: Tks @daniel et @aaa bbb. Ma première réponse était fausse.

import java.util.Random;

public class MyClass {
     public static void main(String args[]) {
          Double min = 0.0;  // Set To Your Desired Min Value
          Double max = 10.0; // Set To Your Desired Max Value
          double x = (Math.random() * ((max - min) + 1)) + min;   // This Will Create A Random Number Inbetween Your Min And Max.
          double xrounded = Math.round(x * 100.0) / 100.0;   // Creates Answer To The Nearest 100 th, You Can Modify This To Change How It Rounds.
          System.out.println(xrounded);    // This Will Now Print Out The Rounded, Random Number.
     }
}

Random random = new Random();
double percent = 10.0; //10.0%
if (random.nextDouble() * 100D < percent) {
    //do
}

L'idée principale de l'aléatoire est qu'il renvoie une valeur pseudo-aléatoire. Il n'existe pas de fonctions entièrement aléatoires, par conséquent, 2 instances aléatoires utilisant la même valeur de départ renverront la même valeur dans certaines conditions.

Il est recommandé de consulter d'abord la documentation de la fonction afin de la comprendre ( https://docs.oracle.com/javase/8/docs/api/java/util/Random.html )

Maintenant que nous comprenons que la valeur retournée de la fonction nextDouble () est une valeur pseudo-aléatoire entre 0,0 et 1,0, nous pouvons l'utiliser à notre avantage.

Pour créer un nombre aléatoire entre A et B donnant que les limites sont valides (A> B), nous devons: 1. trouver la plage entre A et B afin que nous puissions savoir combien de "pas" nous avons. 2. utilisez la fonction aléatoire pour déterminer le nombre d'étapes à effectuer (comme la valeur renvoyée est comprise entre 0,0 et 1,0, vous pouvez la considérer comme "choisir un pourcentage d'augmentation aléatoire" 3. ajouter le décalage

Après tout cela, vous pouvez voir que la foule vous a donné le moyen le plus simple et le plus courant de le faire à mon avis

double randomValue = rangeMin + (rangeMax - rangeMin) * r.nextDouble ();

double RandomValue = Offset + (Range) * (randomVal entre 0.0-1.0)