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

143

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.

java random

— swati
source

237

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

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

— foule
source

21

C'est généralement correct, mais méfiez-vous de ses limites. Si vous le faites double rangeMax= Double.MAX_VALUE;et double rangeMin= -rangeMax;vous obtiendrez toujours une valeur infinie en retour. Vous voudrez peut-être vérifier Double.valueOf(rangeMax-rangeMin).isInfinite().

— lre

Notez que les résultats de ceci excluront souvent de nombreuses valeurs doubles dans la plage souhaitée, si cette plage est supérieure à 0,0-1,0. Si la plage souhaitée contient un plus grand nombre de valeurs que la plage de 0,0 à 1,0, il n'y aura pas de valeur pour chacune d'elles et elles ne seront jamais générées. (Par le principe du casier!). En raison de cette solution Tunaki est meilleure.

— Lii

@Lii il n'y aura pas de valeur pour chacun d'eux pourquoi pas?

— Kartik Chugh

1

@ K_7: Disons par exemple qu'il y a 10 000 valeurs doubles distinctes entre 0,0 et 1,0 (en réalité il y en a probablement plus). Mais si la plage entre rangeMinet rangeMaxest grande, il peut y avoir 10 000 000 valeurs doubles distinctes entre elles. Le résultat de (rangeMax - rangeMin) * r.nextDouble()ne choisira qu'entre 10 000 de ces 10 000 000 valeurs possibles. (Je pense que ce n'est pas une explication parfaite, mais peut-être que cela aide un peu ...)

— Lii

1

Ah, je vois. Fondamentalement, multiplier un nombre qui peut prendre un ensemble fini de valeurs ne change pas la taille de cet ensemble.

— Kartik Chugh

138

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.

— Tunaki
source

6

l'appel nécessite l'api 21

— Zar E Ahmer

2

@XarEAhmer Qu'est-ce que l'API 21?

— Abhijit Sarkar

On dirait qu'il fait référence à Android.

— Kartik Chugh

40

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.

— Topera
source

4

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.
     }
}

— Larson Carter
source

0

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

— Tau
source

0

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)

— Yair Landmann
source