Qual è la differenza tra Math.random() * neRandom.nextInt(n) dove nè un numero intero?
Risposte:
Ecco la spiegazione dettagliata del perché " Random.nextInt(n)è più efficiente e meno distorto di Math.random() * n" dai post dei forum Sun a cui Gili ha collegato:
Math.random () utilizza Random.nextDouble () internamente.
Random.nextDouble () usa Random.next () due volte per generare un doppio che ha nella sua mantissa i bit distribuiti approssimativamente in modo approssimativo, quindi è distribuito uniformemente nell'intervallo da 0 a 1- (2 ^ -53).
Random.nextInt (n) usa Random.next () in media meno di due volte- lo usa una volta, e se il valore ottenuto è al di sopra del multiplo più alto di n al di sotto di MAX_INT ci riprova, altrimenti restituisce il valore modulo n (questo impedisce i valori al di sopra del multiplo più alto di n al di sotto di MAX_INT inclinando la distribuzione), quindi restituendo un valore che è distribuito uniformemente nell'intervallo da 0 a n-1.
Prima di ridimensionare di 6, l'output di Math.random () è uno dei 2 ^ 53 possibili valori tratti da una distribuzione uniforme.
Il ridimensionamento di 6 non modifica il numero di valori possibili e il casting su un int quindi forza questi valori in uno dei sei 'bucket' (0, 1, 2, 3, 4, 5), ogni bucket corrispondente agli intervalli che comprendono 1501199875790165 o 1501199875790166 dei possibili valori (poiché 6 non è un disorder di 2 ^ 53). Ciò significa che per un numero sufficiente di tiri di dado (o un dado con un numero sufficientemente ampio di lati), il dado si mostrerà distorto verso i secchi più grandi.
Aspetterai molto tempo lanciando i dadi affinché questo effetto si manifesti.
Anche Math.random () richiede circa il doppio dell'elaborazione ed è soggetto a sincronizzazione.
6con 5su un cubo di dadi: sarà "di parte 5". Puoi lanciare i dadi un paio di volte prima di notare che qualcosa non va nei dadi. Sei costretto a eseguire un esame approfondito estremamente sofisticato prima di notare che qualcosa non va in un generatore casuale.
Secondo https://forums.oracle.com/forums/thread.jspa?messageID=6594485龵 Random.nextInt(n) è sia più efficiente che meno distorto rispetto aMath.random() * n
Secondo questo esempio Random.nextInt(n)ha un output meno prevedibile di Math.random () * n. Secondo [array ordinato più veloce di un array non ordinato] [1] Penso che possiamo dire che Random.nextInt (n) è difficile da prevedere .
usingRandomClass: tempo: 328 miglia al secondo.
usingMathsRandom: tempo: 187 miglia al secondo.
package javaFuction;
import java.util.Random;
public class RandomFuction
{
static int array[] = new int[9999];
static long sum = 0;
public static void usingMathsRandom() {
for (int i = 0; i < 9999; i++) {
array[i] = (int) (Math.random() * 256);
}
for (int i = 0; i < 9999; i++) {
for (int j = 0; j < 9999; j++) {
if (array[j] >= 128) {
sum += array[j];
}
}
}
}
public static void usingRandomClass() {
Random random = new Random();
for (int i = 0; i < 9999; i++) {
array[i] = random.nextInt(256);
}
for (int i = 0; i < 9999; i++) {
for (int j = 0; j < 9999; j++) {
if (array[j] >= 128) {
sum += array[j];
}
}
}
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
usingRandomClass();
long end = System.currentTimeMillis();
System.out.println("usingRandomClass " + (end - start));
start = System.currentTimeMillis();
usingMathsRandom();
end = System.currentTimeMillis();
System.out.println("usingMathsRandom " + (end - start));
}
}
Math.random()