Explication détaillée de la méthode de génération et du principe des nombres aléatoires en Java

Comment et principe des nombres aléatoires en java

Vérifiez les informations relatives aux nombres aléatoires et organisez-les spécialement

Tout d'abord, parlons de plusieurs façons de générer des nombres aléatoires en Java

1. Dans J2SE, nous pouvons utiliser la méthode math.random () pour générer un nombre aléatoire. Le nombre aléatoire généré est un double entre 0-1. Nous pouvons le multiplier par 100. C'est un nombre aléatoire à moins de 100. Ce n'est pas disponible dans J2Me.
2. Le package Java.util fournit une classe aléatoire. Nous pouvons créer un nouvel objet aléatoire pour générer des nombres aléatoires. Il peut produire des entiers aléatoires, des flotteurs aléatoires, des doubles aléatoires et des longs aléatoires. Il s'agit également d'une méthode pour prendre des nombres aléatoires que nous utilisons souvent dans les programmes J2ME.
3. Il existe une méthode CurrentTimemillis () dans notre classe système. Cette méthode renvoie un numéro de milliseconde à partir de 0h00 du 1er janvier 1970 à celui actuel. Le type de retour est long. Nous pouvons l'utiliser comme nombre aléatoire. Nous pouvons l'utiliser pour modulo certains nombres, et nous pouvons le limiter à une plage.

Fr. . . En fait, la troisième méthode ci-dessus est utilisée pour générer des nombres aléatoires dans la méthode de construction par défaut de Random.

Il existe deux façons de construire une classe aléatoire dans la méthode 2: avec des graines et sans graines

Sans graines: cette méthode renverra des nombres aléatoires, et les résultats de chaque exécution sont différents, ce qui équivaut à l'utilisation de System.CurrentTimemillis () comme graine.

Avec les semences: de cette manière, le résultat de retour sera le même, peu importe le nombre de fois que le programme est exécuté. Si deux instances aléatoires sont créées avec la même graine, la même séquence d'appels de méthode est effectuée à chaque instance et elles généreront et renverront la même séquence de nombres.

Numéro pseudo-aléatoire

Les nombres aléatoires dans les ordinateurs sont des nombres pseudo-aléatoires

Voici un programme C comme celui-ci:

 // rand_1.cpp # inclut <stdlib.h> statique unsigned int rand_seed; unsigned int random (void) {rand_seed = (rand_seed * 123 + 59)% 65536; return (rand_seed);} void random_start (void) {int temp [2]; Souinata (0x0040,0x006c, fp_seg (temp), fp_off (temp), 4); Rand_seed = temp [0];} void main () {unsigned int i, n; random_start (); pour (i = 0; i <10; i ++) printf ("# u / t", random ()); printf ("/ n");}

Il explique pleinement le processus de génération de nombres aléatoires:

d'abord,

Souinata (0x0040,0x006c, fp_seg (temp), fp_off (temp), 4);

Cette fonction est utilisée pour déplacer des données de mémoire. FP_SEG (Pointer to segment) est une fonction qui prend l'adresse du segment du tableau temporaire, FP_off (pointeur lointain vers le décalage) est une fonction qui prend l'adresse relative du tableau temporaire, et la fonction Moveta est de placer les mots doubles situés dans le 0040: 006CH Unité de stockage dans les deux unités de mémoire déclarées par la température de tableau. De cette façon, un numéro 16 bits à 0040: 006ch peut être envoyé à Rand_seed via le tableau temporaire.
Deuxième,

Rand_seed = (rand_seed * 123 + 59)% 65536;

Il s'agit d'une méthode utilisée pour calculer les nombres aléatoires. La méthode de calcul des nombres aléatoires est différente dans différents ordinateurs, même dans différents systèmes d'exploitation installés dans le même ordinateur. Je l'ai essayé respectivement dans Linux et Windows. Les nombres aléatoires générés par les mêmes graines aléatoires dans ces deux systèmes d'exploitation sont différents, ce qui signifie qu'ils ont des méthodes de calcul différentes.

Alors,

Souinata (0x0040,0x006c, fp_seg (temp), fp_off (temp), 4);

Pourquoi les graines aléatoires doivent-elles être récupérées à 0040: 006ch en mémoire? Qu'est-ce qui est stocké à 0040: 006ch?

Ceux qui ont étudié le cours "Principes des composants informatiques et de la technologie d'interface" peuvent se rappeler que lors de la compilation du programme de service d'interruption d'horloge BIOS ROM, le chronométrage / compteur Intel 8253 est utilisé. Sa communication avec la puce d'interruption Intel 8259 permet au programme de service d'interruption de fonctionner. Les 18,2 interruptions générées par la carte mère par seconde sont générées par le processeur contrôle la puce d'interruption en fonction de la valeur de synchronisation / compteur. Il existe un tel timing / compteur sur la carte mère de notre ordinateur pour calculer le temps du système actuel. Le compteur sera ajouté un à chaque fois qu'un cycle de signal d'horloge passe. Où est la valeur de ce compteur stocké? C'est vrai, juste à 0040: 006ch en mémoire, cet espace mémoire est en fait défini comme ceci:

Timer_low dw ?; L'adresse est 0040: 006ch
Timer_high dw ?; L'adresse est 0040: 006EH
TIMER_OFT DB? ; L'adresse est 0040: 0070H

Dans le programme de service d'interruption d'horloge, chaque fois que TIMER_LOW devient plein, le compteur deviendra également plein et que la valeur du compteur est nulle, c'est-à-dire que le binaire 16 bits à Timer_Low est à zéro et Timer_High en est ajouté un. Dans rand01.c

Souinata (0x0040,0x006c, fp_seg (temp), fp_off (temp), 4);

Il s'agit précisément des deux nombres binaires 16 bits TIMER_LOW et TIMER_HIGH qui sont placés dans le tableau temporaire et envoyés à Rand_seed, obtenant ainsi la "graine aléatoire".
Maintenant, une chose qui peut être déterminée est que la graine aléatoire provient de l'horloge du système, ou plutôt, la valeur d'enregistrement en mémoire à partir du synchronisation / compteur de la carte mère de l'ordinateur.

En ... non dernier. . lvl--

Regardons un autre morceau de code:

 //rand_2.cpp#include <iostream> #include <cstdlib> en utilisant le namespace std; int main () {srand ((unsigned) time (null)); non signé int r = rand (); cout << "r =" << r << endl; // Selon la norme C ++ 98, la fonction principale peut être introduite sans utiliser l'instruction de retour pour retourner 0;}

Ici, si l'utilisateur et d'autres programmes ne définissent pas de graine aléatoire, la valeur du synchronisation / compteur du système est utilisée comme graine aléatoire. Par conséquent, dans le même environnement de plate-forme, après avoir compilé et généré un EXE, chaque fois que vous l'exécutez, le nombre aléatoire affiché sera un numéro pseudo-aléatoire, c'est-à-dire que les résultats affichés seront différents chaque fois que vous l'exécutez.

Résumer

Les nombres aléatoires sont des valeurs calculées par des graines aléatoires en fonction de certaines méthodes de calcul. Par conséquent, tant que la méthode de calcul est certaine et que la graine aléatoire est certaine, le nombre aléatoire généré ne changera pas. Dans le même environnement de plate-forme, après avoir compilé et généré un EXE, les nombres aléatoires affichés sont les mêmes chaque fois que vous l'exécutez. En effet, dans le même environnement de plate-forme de compilation, les méthodes de calcul pour générer des nombres aléatoires à partir de graines aléatoires sont les mêmes, et les graines aléatoires sont les mêmes, donc les nombres aléatoires générés sont les mêmes.

Tant que l'utilisateur ou le tiers ne définit pas de graine aléatoire, alors par défaut, la graine aléatoire provient de l'horloge du système (c'est-à-dire la valeur du synchronisation / compteur)

Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!