java - new - Math.random() versus Random.nextInt(int)

random nextint java

Question

¿Cuál es la diferencia entre Math.random() * n y Random.nextInt(n) donde n es un número entero?

Answer 1

Aquí está la explicación detallada de por qué " Random.nextInt(n) es más eficiente y menos sesgado que Math.random() * n " desde la publicación de los foros de Sun a la que Gili se vinculó:

Math.random () usa Random.nextDouble () internamente.

Random.nextDouble () usa Random.next () dos veces para generar un doble que tiene bits distribuidos de manera uniforme en su mantisa, por lo que se distribuye uniformemente en el rango de 0 a 1- (2 ^ -53).

Random.nextInt (n) usa Random.next () menos de dos veces en promedio, lo usa una vez, y si el valor obtenido está por encima del múltiplo más alto de n por debajo de MAX_INT, lo intenta de nuevo; de lo contrario, devuelve el valor modulo n ( evita los valores superiores al múltiplo más alto de n por debajo de MAX_INT sesgando la distribución), por lo que se devuelve un valor que se distribuye uniformemente en el rango de 0 a n-1.

Antes de escalar por 6, la salida de Math.random () es uno de los 2 ^ 53 valores posibles extraídos de una distribución uniforme.

Escalar por 6 no altera el número de valores posibles, y fundir en un int luego fuerza estos valores en uno de los seis ''cubos'' (0, 1, 2, 3, 4, 5), cada cubo correspondiente a rangos que abarcan 1501199875790165 o 1501199875790166 de los valores posibles (ya que 6 no es un consejero de 2 ^ 53). Esto significa que para un número suficiente de dados (o un dado con un número suficientemente grande de lados), el dado mostrará que está sesgado hacia los cubos más grandes.

Esperarás mucho tiempo rodando dados para que aparezca este efecto.

Math.random () también requiere aproximadamente el doble de procesamiento y está sujeto a sincronización.

Answer 2

De acuerdo con https://forums.oracle.com/forums/thread.jspa?messageID=6594485&#6594485 Random.nextInt(n) es más eficiente y menos sesgado que Math.random() * n

Answer 3

De acuerdo con este ejemplo, Random.nextInt(n) tiene un resultado menos predecible que Math.random () * n. De acuerdo con [matriz ordenada más rápido que una matriz no ordenada] [1], creo que podemos decir que Random.nextInt (n) es difícil de predecir .

usingRandomClass: tiempo: 328 millas de segundo.

usingMathsRandom: tiempo: 187 millas de segundo.

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));
}
}

Answer 4

Otro punto importante es que Random.nextInt (n) es repetible ya que puedes crear dos objetos aleatorios con la misma semilla. Esto no es posible con Math.random ().