Classe aléatoire (java.util)
L'algorithme aléatoire implémenté dans la classe aléatoire est le pseudo-aléatoire, c'est-à-dire aléatoire avec des règles. Lors de la randomisation, le nombre d'origine de l'algorithme aléatoire est appelé graines, qui effectue une certaine transformation basée sur les graines, générant ainsi les nombres aléatoires requis.
Des objets aléatoires avec le même nombre de graines, les nombres aléatoires générés par le même nombre de fois sont exactement les mêmes. En d'autres termes, pour deux objets aléatoires avec le même nombre de graines, les nombres aléatoires générés pour la première fois sont exactement les mêmes, et les nombres aléatoires générés pour la deuxième fois sont exactement les mêmes. Cela nécessite une attention particulière lors de la génération de plusieurs nombres aléatoires.
Ce qui suit décrit l'utilisation de la classe aléatoire, ainsi que la façon de générer un tableau aléatoire d'intervalles spécifiés et les chances requises dans le programme de mise en œuvre.
1. Génération d'objets aléatoires
La classe aléatoire contient deux constructeurs, qui sont introduits dans la séquence ci-dessous:
un. public aléatoire ()
Cette méthode de construction utilise un nombre lié au temps relatif correspondant au temps du système actuel comme nombre de graines, puis utilise ce numéro de graine pour construire l'objet aléatoire.
né Random public (graine longue)
Ce constructeur peut être créé en formulant un numéro de semence.
Exemple de code:
La copie de code est la suivante:
Random r = new Random ();
Random r1 = nouveau aléatoire (10);
Encore une fois: le nombre de graines n'est que le nombre d'origine de l'algorithme aléatoire et n'a rien à voir avec l'intervalle des nombres aléatoires générés.
2. Méthodes courantes en classe aléatoire
Les méthodes de la classe aléatoire sont relativement simples et les fonctions de chaque méthode sont également faciles à comprendre. Il convient de noter que les nombres aléatoires générés par chaque méthode de la classe aléatoire sont uniformément distribués, ce qui signifie que la probabilité de génération numérique dans l'intervalle est égale. Voici une introduction de base à ces méthodes:
un. public booléen nextboolean ()
La fonction de cette méthode est de générer une valeur booléenne aléatoire, et la probabilité de générer des valeurs vraies et fausses est égale, c'est-à-dire que les deux sont de 50%.
né public Double NextDouble ()
Le but de cette méthode est de générer une double valeur aléatoire, avec la valeur entre [0, 1.0).
C, public int nextInt ()
Le but de cette méthode est de générer une valeur int aléatoire, qui se situe entre -231 et 231-1.
Si vous devez générer une valeur int pour un intervalle spécifié, vous devez effectuer une certaine transformation mathématique. Pour plus de détails, veuillez consulter le code dans l'exemple d'utilisation ci-dessous.
D, public int nextInt (int n)
La fonction de cette méthode est de générer une valeur int aléatoire, qui se situe dans l'intervalle de [0, n), c'est-à-dire une valeur int aléatoire entre 0 et n, contenant 0 mais pas n.
Si vous souhaitez générer une valeur int pour un intervalle spécifié, vous devez également effectuer une certaine transformation mathématique. Pour plus de détails, veuillez consulter le code dans l'exemple d'utilisation ci-dessous.
E, SETCHEED PUBLIQUE (SEMENT LONGE)
Le but de cette méthode est de réinitialiser le nombre de graines dans l'objet aléatoire. Après avoir défini le nombre de graines, l'objet aléatoire est le même que l'objet aléatoire créé avec le nouveau mot-clé.
3. Exemple d'utilisation de classe aléatoire
En utilisant la classe aléatoire, il s'agit généralement de générer des nombres aléatoires pour un intervalle spécifié. Ce qui suit présentera comment générer des nombres aléatoires pour un intervalle correspondant un par un. Les codes suivants qui génèrent des nombres aléatoires sont générés en utilisant l'objet aléatoire suivant R:
Random r = new Random ();
un. Générer des décimales de l'intervalle [0, 1.0)
La copie de code est la suivante:
Double D1 = R.NextDouble ();
Il est obtenu directement en utilisant la méthode NextDouble.
né Générer des décimales de l'intervalle [0,5.0)
La copie de code est la suivante:
Double D2 = R.NextDouble () * 5;
Étant donné que l'intervalle de nombre généré par la méthode NextDouble est [0, 1.0), l'élargissement de l'intervalle de 5 fois est l'intervalle requis.
De même, pour générer une décimale aléatoire dans l'intervalle [0, d) et d est une décimale positive, il vous suffit de multiplier la valeur de retour de la méthode NextDouble par d.
c. Générer des décimales dans l'intervalle [1,2,5)
La copie de code est la suivante:
Double D3 = R.NextDouble () * 1,5 + 1;
Pour générer une décimale aléatoire de l'intervalle [1, 2,5), vous n'avez qu'à générer d'abord un nombre aléatoire de l'intervalle [0, 1,5), puis d'ajouter 1 à l'intervalle de nombre aléatoire généré.
De même, pour générer n'importe quel nombre aléatoire dans la plage d'intervalle décimal [d1, d2) qui ne commence pas à partir de 0 (où D1 n'est pas égal à 0), il vous suffit de générer d'abord un nombre aléatoire dans l'intervalle [0, D2-D1), puis d'ajouter l'intervalle de nombre aléatoire généré à D1.
d. Générer un entier
La copie de code est la suivante:
int n1 = r.Nextint ();
Utilisez simplement la méthode NextInt directement.
e. Générer des entiers dans l'intervalle [0,10)
La copie de code est la suivante:
int n2 = r.Nextint (10);
n2 = math.abs (r.Nextint ()% 10);
Les deux lignes de code ci-dessus peuvent générer des entiers dans l'intervalle [0,10).
La première implémentation est directement implémentée à l'aide de la méthode NextInt (int n) dans la classe aléatoire.
Dans la deuxième implémentation, appelez d'abord NextInt () pour générer un numéro INT arbitraire. L'intervalle généré par la somme numérique de 10 est (-10,10), puis trouvera la valeur absolue de l'intervalle, et l'intervalle obtenu est [0,10).
De même, pour générer des entiers aléatoires dans n'importe quel intervalle [0, n), vous pouvez utiliser le code suivant:
La copie de code est la suivante:
int n2 = r.Nextint (n);
n2 = math.abs (r.Nextint ()% n);
f. Générer des entiers dans l'intervalle [0,10]
La copie de code est la suivante:
int n3 = r.Nextint (11);
n3 = math.abs (r.Nextint ()% 11);
Par rapport à l'intervalle entier, l'intervalle [0,10] et l'intervalle [0,11) sont équivalents, donc un entier de l'intervalle [0,11) est généré.
g. Générer des entiers dans l'intervalle [-3,15)
La copie de code est la suivante:
int n4 = r.Nextint (18) - 3;
n4 = math.abs (r.Nextint ()% 18) - 3;
Pour générer des entiers aléatoires qui ne commencent pas à partir de 0, vous pouvez vous référer à la description ci-dessus du principe de mise en œuvre de l'intervalle décimal qui ne commence pas de 0.
H, chance d'atteindre
La mise en œuvre de la logique du programme en fonction d'une certaine chance est également un problème qui peut être résolu par un traitement aléatoire. Voici un exemple simple pour montrer comment implémenter la logique du hasard à l'aide de nombres aléatoires.
Dans l'introduction de la méthode précédente, les nombres générés dans la méthode suivante (int n) sont uniformes, c'est-à-dire que les chances de génération de chaque nombre dans l'intervalle sont les mêmes. Ensuite, si un entier aléatoire dans l'intervalle [0,100) est généré, les chances de générer les chances de chaque nombre doivent être les mêmes, et comme il y a 100 entiers dans l'intervalle, les chances de chaque nombre sont de 1%. Selon cette théorie, le problème de probabilité du programme peut être réalisé.
Exemple: générer de manière aléatoire un entier qui génère 1 avec 55% de chances, 2 avec 40% de chances et 3 avec 5% de chances. Le code implémenté est le suivant:
La copie de code est la suivante:
int n5 = r.Nextint (100);
int m; // Numéro de résultat
if (n5 <55) {// l'intervalle de 55 nombres, 55% de chance
M = 1;
} else if (n5 <95) {// [55,95), intervalle de 40 nombres, 40% de chance
M = 2;
}autre{
M = 3;
}
Étant donné que la probabilité de chaque nombre est de 1%, la probabilité de tout intervalle à 55 chiffres est de 55%. Pour la commodité d'écrire le code, tous les entiers de l'intervalle [0,55) sont utilisés ici, et le principe suivant est le même.
Bien sûr, le code ici peut être simplifié car les cotes sont des multiples de 5%, donc contrôlez simplement les chances en fonction de 5%. Ce qui suit est l'implémentation de code simplifiée:
La copie de code est la suivante:
int n6 = r.Nextint (20);
int m1;
if (n6 <11) {
m1 = 1;
} else if (n6 <19) {
m1 = 2;
}autre{
m1 = 3;
}
À l'intérieur du programme, la logique de la probabilité peut être mise en œuvre en fonction des instructions ci-dessus.
4. Autres problèmes
un. Le problème de l'objet aléatoire avec le même numéro de graine
Comme mentionné précédemment, les objets aléatoires avec le même nombre de graines ont les mêmes nombres aléatoires générés par le même nombre de fois. Ce qui suit est le code de test:
La copie de code est la suivante:
Random r1 = nouveau aléatoire (10);
Random R2 = nouveau aléatoire (10);
pour (int i = 0; i <2; i ++) {
System.out.println (R1.Nextint ());
System.out.println (r2.Nextint ());
}
Dans ce code, le nombre de graines utilisés par les objets R1 et R2 est 10, donc les nombres aléatoires générés par le même nombre de fois sont exactement les mêmes.
Si vous souhaitez éviter la situation où les nombres aléatoires sont les mêmes, vous devez noter que peu importe le nombre de nombres aléatoires que vous devez générer dans le projet, vous ne pouvez utiliser qu'un seul objet aléatoire.
né À propos de la méthode aléatoire de la classe de mathématiques
En fait, il existe également une méthode aléatoire dans la classe de mathématiques. Le travail de cette méthode aléatoire consiste à générer une décimale aléatoire de l'intervalle [0, 1.0).
En lisant le code source de la classe de mathématiques, nous pouvons constater que la méthode aléatoire de la classe de mathématiques est implémentée en appelant directement la méthode NextDouble dans la classe aléatoire.
C'est juste que la méthode aléatoire est appelée relativement simple, donc de nombreux programmeurs sont habitués à utiliser la méthode aléatoire de la classe de mathématiques pour générer des nombres aléatoires.