Genera un doppio casuale in un intervallo

143

Ho due doppi come il seguente

double min = 100;
double max = 101;

e con un generatore casuale, ho bisogno di creare un doppio valore tra la gamma di min e max.

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

ma qui non c'è nulla in cui possiamo specificare l'intervallo.

java random

— Swati
fonte

237

Per generare un valore casuale tra rangeMine rangeMax:

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

— mob
fonte

21

Questo è generalmente corretto, ma attenzione ai suoi limiti. Se lo fai double rangeMax= Double.MAX_VALUE;e double rangeMin= -rangeMax;otterrai sempre un valore infinito in cambio. Potresti voler verificare Double.valueOf(rangeMax-rangeMin).isInfinite().

— lre,

Si noti che i risultati di questo spesso escluderanno molti valori doppi nell'intervallo desiderato, se tale intervallo è maggiore di 0,0-1,0. Se l'intervallo desiderato contiene un numero di valori maggiore dell'intervallo 0,0-1,0, non ci sarà un valore per ciascuno di essi e non verranno mai generati. (Secondo il principio del buco del piccione!). Per questo motivo la soluzione di Tunaki è migliore.

— Lii,

@Lii non ci sarà un valore per ognuno di loro, perché no?

— Kartik Chugh,

1

@ K_7: supponiamo ad esempio che ci siano 10.000 valori doppi distinti tra 0,0 e 1,0 (in realtà probabilmente ce ne sono altri). Ma se l'intervallo tra rangeMine rangeMaxè grande, potrebbero esserci 10.000.000 di doppi valori distinti tra loro. Il risultato di (rangeMax - rangeMin) * r.nextDouble()sceglierà solo tra 10.000 di quei possibili 10.000.000 di valori. (Sento che questa non è una spiegazione perfetta, ma forse aiuta un po '...)

— Lii

1

Ah capisco Fondamentalmente, moltiplicare un numero che può assumere un set finito di valori non cambia la dimensione di quel set.

— Kartik Chugh,

138

Questa domanda è stata posta prima del rilascio di Java 7, ma ora esiste un altro modo per utilizzare l'API Java 7 (e versioni successive):

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

nextDoublerestituirà un doppio valore pseudocasuale tra il minimo (compreso) e il massimo (esclusivo). I limiti non sono necessariamente inte possono esserlo double.

— Tunaki
fonte

6

la chiamata richiede api 21

— Zar E Ahmer,

2

@XarEAhmer Cos'è l'API 21?

— Abhijit Sarkar

Sembra che si stia riferendo ad Android.

— Kartik Chugh,

40

Usa questo:

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

MODIFICARE:

new Random().nextDouble(): genera casualmente un numero compreso tra 0 e 1.

start: inizio numero, per spostare il numero "a destra"

end - start: intervallo. Casuale ti dà dallo 0% al 100% di questo numero, perché casuale ti dà un numero da 0 a 1.

EDIT 2: Tks @daniel e @aaa bbb. La mia prima risposta era sbagliata.

— topera
fonte

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
fonte

0

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

— Tau
fonte

0

L'idea principale di random è che restituisce un valore pseudocasuale. Non esistono funzioni completamente casuali, quindi 2 istanze casuali che utilizzano lo stesso seed restituiranno lo stesso valore in determinate condizioni.

È buona norma visualizzare prima il documento di funzione per comprenderlo ( https://docs.oracle.com/javase/8/docs/api/java/util/Random.html )

Ora che comprendiamo che il valore restituito della funzione nextDouble () è un valore pseudocasuale compreso tra 0,0 e 1,0, possiamo usarlo a nostro vantaggio.

Per creare un numero casuale tra A e B, in modo che i limiti siano validi (A> B), dobbiamo: 1. trovare l'intervallo tra A e B in modo da poter sapere quanti "passi" abbiamo. 2. usa la funzione casuale per determinare quanti passaggi intraprendere (poiché il valore restituito è compreso tra 0,0 e 1,0 puoi considerarlo come "scegli una percentuale casuale di aumento" 3. aggiungi l'offset

Dopotutto, puoi vedere che mob ti ha dato il modo più semplice e comune per farlo secondo me

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

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

— Yair Landmann
fonte