1. Comment générer des nombres aléatoires Java
En Java, il existe trois concepts généraux de nombres aléatoires.
1. Utilisez System.Currenttimemillis () pour obtenir un nombre long de millisecondes de type à l'heure actuelle.
2. Renvoie une double valeur entre 0 et 1 via math.random ().
3. Générez un nombre aléatoire via la classe aléatoire.
2. Description de l'API aléatoire
1. Description de l'API Java
Une instance de la classe aléatoire est utilisée pour générer un flux de nombres pseudo-aléatoires. Cette classe utilise des graines 48 bits et les modifie à l'aide de formules de congruence linéaire (voir l'art de la programmation informatique de Donald Knuth, volume 2, section 3.2.1).
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. Afin de garantir la mise en œuvre des attributs, un algorithme spécifique est spécifié pour la classe aléatoire.
De nombreuses applications trouveront la méthode aléatoire dans la classe de mathématiques plus facile à utiliser.
2. Résumé de la méthode
Aléatoire()
Créez un nouveau générateur de nombres aléatoires.
Aléatoire (graine longue)
Créez un nouveau générateur de nombres aléatoires en utilisant une seule graine longue:
Public Random (Long Seed) {Setseed (Seed);} La méthode suivante l'utilise pour enregistrer l'état du générateur de nombres aléatoires.
protégé INT NEXT (INT BITS)
Générez le prochain numéro pseudo-aléatoire.
booléen nextboolean ()
Renvoie le numéro pseudo-aléatoire suivant, qui est une valeur booléenne uniformément distribuée tirée de la séquence de ce générateur de nombres aléatoires.
void NextBytes (octets [] octets)
Générez des octets aléatoires et placez-les dans un tableau d'octets fourni par l'utilisateur.
Double NextDouble ()
Renvoie le numéro pseudo-aléatoire suivant, qui est réparti également réparti entre 0,0 et 1,0, tiré de la séquence de ce générateur de nombres aléatoires.
float nextfloat ()
Renvoie le numéro pseudo-aléatoire suivant, qui est une valeur de flotteur uniformément réparti entre 0,0 et 1,0, tiré de la séquence de ce générateur de nombres aléatoires.
Double NextGaussien ()
Renvoie le numéro pseudo-aléatoire suivant, qui est une distribution gaussienne ("normalement") tirée de la séquence de ce générateur de nombres aléatoires, avec une moyenne de 0,0 et un écart-type de 1,0.
int nextInt ()
Renvoie le numéro pseudo-aléatoire suivant, qui est la valeur intyment répartie dans la séquence de ce générateur de nombres aléatoires.
int nextInt (int n)
Renvoie un nombre pseudo-aléatoire, qui est réparti uniformément entre 0 (y compris) et la valeur spécifiée (à l'exclusion) tirée de la séquence de ce générateur de nombres aléatoires.
long nextLong ()
Renvoie le numéro pseudo-aléatoire suivant, qui est une valeur longue uniformément distribuée tirée de la séquence de ce générateur de nombres aléatoires.
vide set (longue graine)
Réglez la graine de ce générateur de nombres aléatoires à l'aide d'une seule graine longue.
3. Instructions d'utilisation de classe aléatoire
1. La différence entre transporter des graines et ne pas transporter de graines
L'utilisation fondamentale de la classe aléatoire est de diviser les instances de hasard avec des graines et sans graines.
En termes simples, la différence entre les deux est:
Pour les graines, le résultat généré par chaque course est le même.
Si vous n'avez pas de graines, ce que vous gérez est aléatoire à chaque fois que vous courez, et il n'y a pas du tout de modèle.
2. Créez un objet aléatoire sans graines
Aléatoire aléatoire = nouveau aléatoire ();
3. Créez un objet aléatoire sans graines
Il y a deux façons:
1) aléatoire aléatoire = nouveau aléatoire (555L);
2) aléatoire aléatoire = nouveau aléatoire ();
Random.Setseed (555L);
4. Application complète
Ce qui suit est une classe d'outils aléatoires récemment écrite pour afficher l'utilisation:
La copie de code est la suivante:
import java.util.random;
/ **
* Numéro aléatoire, outil de chaîne
* Utilisateur: Leizhimin
* Date: 2008-11-19 9:43:09
* /
classe publique Randomutils {
Public static final String allchar = "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
public static final string wetterchar = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
Public static final string numéroChar = "0123456789";
/ **
* Renvoie une chaîne aléatoire de longueur fixe (y compris uniquement les lettres et nombres supérieurs et inférieurs)
*
* Longueur de chaîne aléatoire de la longueur @param
* @return chaîne aléatoire
* /
String statique publique GenerateString (int longueur) {
StringBuffer sb = new StringBuffer ();
Aléatoire aléatoire = nouveau aléatoire ();
pour (int i = 0; i <longueur; i ++) {
SB.APPEND (Allchar.Charat (Random.Nextint (Allchar.Length ())));
}
return sb.toString ();
}
/ **
* Renvoie une chaîne de lettres pure aléatoire de longueur fixe (y compris uniquement les lettres supérieures et minuscules)
*
* Longueur de chaîne aléatoire de la longueur @param
* @return chaîne aléatoire
* /
public static String generatemixString (int longueur) {
StringBuffer sb = new StringBuffer ();
Aléatoire aléatoire = nouveau aléatoire ();
pour (int i = 0; i <longueur; i ++) {
SB.APPEND (Allchar.Charat (Random.Nextint (LetterChar.Length ())));
}
return sb.toString ();
}
/ **
* Renvoie une chaîne de lettres de capital pure aléatoire de longueur fixe (y compris uniquement les lettres de boîtier supérieur)
*
* Longueur de chaîne aléatoire de la longueur @param
* @return chaîne aléatoire
* /
public static String generatelowerString (int longueur) {
return generatemixString (longueur) .tolowerCase ();
}
/ **
* Renvoie une chaîne en minuscules pure aléatoire de longueur fixe (y compris uniquement des lettres majuscules et minuscules)
*
* Longueur de chaîne aléatoire de la longueur @param
* @return chaîne aléatoire
* /
La chaîne statique publique GenerateUpperString (int longueur) {
return generateMixString (longueur) .toupperCase ();
}
/ **
* Générer une chaîne pure 0 de longueur fixe
*
* Longueur de la longueur de longueur @param
* @return pure 0 chaîne
* /
String statique publique GenerateZeroString (int longueur) {
StringBuffer sb = new StringBuffer ();
pour (int i = 0; i <longueur; i ++) {
SB.APPEND ('0');
}
return sb.toString ();
}
/ **
* Générez une chaîne de longueur fixe en fonction du nombre, la longueur n'est pas suffisante pour être ajoutée à la précédente.
*
* Numéro @param num
* @param fixedlenth string longueur
* @return String de longueur fixe
* /
String statique public tofixdlengthstring (long num, int fixdlenth) {
StringBuffer sb = new StringBuffer ();
String strnum = string.valueof (num);
if (fixdlenth - strnum.length ()> = 0) {
SB.APPEND (GenerateLeroString (fixdlenth - strnum.length ()));
} autre {
lancer un nouveau runtimeException ("convertir le nombre" + num + "en une chaîne avec la longueur" + fixdlenth + "L'exception se produit!");
}
SB.APPEND (Strnum);
return sb.toString ();
}
/ **
* Générez une chaîne de longueur fixe en fonction du nombre, la longueur n'est pas suffisante pour être ajoutée à la précédente.
*
* Numéro @param num
* @param fixedlenth string longueur
* @return String de longueur fixe
* /
String statique public tofixdlengthString (int num, int fixdlenth) {
StringBuffer sb = new StringBuffer ();
String strnum = string.valueof (num);
if (fixdlenth - strnum.length ()> = 0) {
SB.APPEND (GenerateLeroString (fixdlenth - strnum.length ()));
} autre {
lancer un nouveau runtimeException ("convertir le nombre" + num + "en une chaîne avec la longueur" + fixdlenth + "L'exception se produit!");
}
SB.APPEND (Strnum);
return sb.toString ();
}
public static void main (String [] args) {
System.out.println (GenerAtString (15));
System.out.println (GenerateMixString (15));
System.out.println (GenerateLowString (15));
System.out.println (GenerateApperString (15));
System.out.println (GeneratezeroString (15));
System.out.println (tofixdlengthString (123, 15));
System.out.println (tofixdlengthstring (123l, 15));
}
}
Résultats en cours:
vwmbpinbzfgcphg
23HYRAHDJKKPWMV
tigowetbwkm1nde
Bpz1knejphb115n
000000000000000000
00000000000000123
00000000000000123
Processus terminé avec le code de sortie 0
6. Résumé
1. Les nombres aléatoires sont très courants.
2. Les objets de classe aléatoire ont une différence entre leur transport de graines.
3. Il existe deux façons de créer des objets de semences avec des nombres aléatoires, avec le même effet. Mais les nombres aléatoires avec les graines ne semblent pas être très utiles.
4. Les fonctions de Random couvrent les fonctions de math.random ().
5. Vous pouvez utiliser des nombres aléatoires pour implémenter des données aléatoires complexes telles que des chaînes aléatoires.
6. N'étudie pas des nombres aléatoires qui ne se répètent pas, ce n'est pas très significatif.
Code supplémentaire:
La copie de code est la suivante:
package com.test;
import java.util.random;
classe publique Randomutils {
Public static final String allchar = "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
public static final string wetterchar = "abcdefghijkllmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
Public static final string numéroChar = "0123456789";
/ **
* Renvoie une chaîne aléatoire de longueur fixe (y compris uniquement les lettres et nombres supérieurs et inférieurs)
* Longueur de chaîne aléatoire de la longueur @param
* @return chaîne aléatoire
* /
GenerateString de chaîne statique publique (longueur int)
{
StringBuffer sb = new StringBuffer ();
Aléatoire aléatoire = nouveau aléatoire ();
pour (int i = 0; i <longueur; i ++) {
SB.APPEND (Allchar.Charat (Random.Nextint (Allchar.Length ())));
}
return sb.toString ();
}
/ **
* Renvoie une chaîne de lettres pure aléatoire de longueur fixe (y compris uniquement les lettres supérieures et minuscules)
* Longueur de chaîne aléatoire de la longueur @param
* @return chaîne aléatoire
* /
STRATIQUE STATIQUE publique GenerateMixString (int le long)
{
StringBuffer sb = new StringBuffer ();
Aléatoire aléatoire = nouveau aléatoire ();
pour (int i = 0; i <longueur; i ++)
{
SB.APPEND (Allchar.Charat (Random.Nextint (LetterChar.Length ())));
}
return sb.toString ();
}
/ **
* Renvoie une chaîne de lettres de capital pure aléatoire de longueur fixe (y compris uniquement les lettres de boîtier supérieur)
*
* Longueur de chaîne aléatoire de la longueur @param
* @return chaîne aléatoire
* /
public static String generatelowerString (int longueur) {
return generatemixString (longueur) .tolowerCase ();
}
/ **
* Renvoie une chaîne en minuscules pure aléatoire de longueur fixe (y compris uniquement des lettres majuscules et minuscules)
*
* Longueur de chaîne aléatoire de la longueur @param
* @return chaîne aléatoire
* /
La chaîne statique publique GenerateUpperString (int longueur) {
return generateMixString (longueur) .toupperCase ();
}
/ **
* Générer une chaîne pure 0 de longueur fixe
*
* Longueur de la longueur de longueur @param
* @return pure 0 chaîne
* /
String statique publique GenerateZeroString (int longueur) {
StringBuffer sb = new StringBuffer ();
pour (int i = 0; i <longueur; i ++) {
SB.APPEND ('0');
}
return sb.toString ();
}
/ **
* Générez une chaîne de longueur fixe en fonction du nombre, la longueur n'est pas suffisante pour être ajoutée à la précédente.
*
* Numéro @param num
* @param fixedlenth string longueur
* @return String de longueur fixe
* /
String statique public tofixdlengthstring (long num, int fixdlenth) {
StringBuffer sb = new StringBuffer ();
String strnum = string.valueof (num);
if (fixdlenth - strnum.length ()> = 0) {
SB.APPEND (GenerateLeroString (fixdlenth - strnum.length ()));
} autre {
lancer un nouveau runtimeException ("convertir le nombre" + num + "en une chaîne avec la longueur" + fixdlenth + "L'exception se produit!");
}
SB.APPEND (Strnum);
return sb.toString ();
}
/ **
* Générez une chaîne de longueur fixe en fonction du nombre, la longueur n'est pas suffisante pour être ajoutée à la précédente.
*
* Numéro @param num
* @param fixedlenth string longueur
* @return String de longueur fixe
* /
String statique public tofixdlengthString (int num, int fixdlenth) {
StringBuffer sb = new StringBuffer ();
String strnum = string.valueof (num);
if (fixdlenth - strnum.length ()> = 0) {
SB.APPEND (GenerateLeroString (fixdlenth - strnum.length ()));
} autre {
lancer un nouveau runtimeException ("convertir le nombre" + num + "en une chaîne avec la longueur" + fixdlenth + "L'exception se produit!");
}
SB.APPEND (Strnum);
return sb.toString ();
}
/ **
* Le nombre de chiffres Len générés à chaque fois est différent
* @param param
* @return Nombre de longueur fixe
* /
public static int getNotsImple (int [] param, int len)
{
Random Rand = new Random ();
pour (int i = param.length; i> 1; i--)
{
int index = rand.nextint (i);
int tmp = param [index];
param [index] = param [i - 1];
param [i - 1] = tmp;
}
INT Result = 0;
pour (int i = 0; i <len; i ++)
{
result = result * 10 + param [i];
}
Résultat de retour;
}
public static void main (String [] args) {
System.out.println (GenerAtString (10));
System.out.println (GenerateMixString (10));
System.out.println (GenerateLowString (10));
System.out.println (GenerateApperString (10));
System.out.println (GenerateZeroString (10));
System.out.println (tofixdlengthString (123, 10));
System.out.println (tofixdlengthstring (123l, 10));
int [] dans = {1,2,3,4,5,6,7};
System.out.println (getNotsImple (in, 3));
}
}