Math.random () versus Random.nextInt (int)

Quelle est la différence entre Math.random() * n et Random.nextInt(n)n est un entier?

Voici l’explication détaillée de la raison pour laquelle ” Random.nextInt(n) est à la fois plus efficace et moins biaisé que Math.random() * n ” dans la publication des forums Sun liée à Gili:

Math.random () utilise Random.nextDouble () en interne.

Random.nextDouble () utilise deux fois Random.next () pour générer un double qui a des bits dissortingbués à peu près uniformément dans sa mantisse, de sorte qu’il est uniformément dissortingbué entre 0 et 1- (2 ^ -53).

Random.nextInt (n) utilise Random.next () moins de deux fois en moyenne – il l’utilise une fois, et si la valeur obtenue est supérieure au multiple le plus élevé de n sous MAX_INT, il tente à nouveau, sinon renvoie la valeur modulo n (this empêche les valeurs supérieures au multiple le plus élevé de n en dessous de MAX_INT de biaiser la dissortingbution), renvoyant ainsi une valeur uniformément répartie dans la plage 0 à n-1.

Avant la mise à l’échelle de 6, la sortie de Math.random () est l’une des 2 ^ 53 valeurs possibles tirées d’une dissortingbution uniforme.

La mise à l’échelle de 6 ne modifie pas le nombre de valeurs possibles et la conversion en un int force ces valeurs dans l’un des six «compartiments» (0, 1, 2, 3, 4, 5), chaque compartiment correspondant à des plages 1501199875790165 ou 1501199875790166 des valeurs possibles (car 6 n’est pas un disjoncteur de 2 ^ 53). Cela signifie que pour un nombre suffisant de dés (ou un dé avec un nombre de côtés suffisamment grand), le dé se révélera être orienté vers les plus grands compartiments.

Vous attendez un très long moment pour lancer cet effet.

Math.random () nécessite également environ deux fois le traitement et est soumis à la synchronisation.

Un autre point important est que Random.nextInt (n) est répétable car vous pouvez créer deux objects aléatoires avec la même graine. Ceci n’est pas possible avec Math.random ().

Selon https://forums.oracle.com/forums/thread.jspa?messageID=6594485&#6594485 Random.nextInt(n) est à la fois plus efficace et moins biaisé que Math.random() * n

Selon cet exemple, Random.nextInt(n) a une sortie moins prévisible que Math.random () * n. Selon [tableau sortingé plus rapidement qu’un tableau non sortingé] [1] je pense que nous pouvons dire que Random.nextInt (n) est difficile à prédire .

usingRandomClass: temps: 328 milesecondes.

usingMathsRandom: time: 187 milesecondes.

 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(Ssortingng[] 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)); } }