3 façons d'obtenir des nombres aléatoires en Java

Auteur：Eve Cole Date de mise à jour：2025-05-06 04:32:01

Il introduit principalement trois méthodes d'obtention de nombres aléatoires en Java, utilisant principalement la fonction aléatoire () pour l'implémenter

Méthode 1

(Type de données) (valeur minimale + math.random () * (valeur maximale -Minim Valeur +1)) Exemple:

 (int) (1 + math.random () * (10-1 + 1))

Type int de 1 à 10

Méthode 2

Obtenir un nombre aléatoire

 for (int i = 0; i <30; i ++) {System.out.println ((int) (1 + math.random () * 10));} (int) (1 + math.random () * 10)

La méthode aléatoire du package java.math obtient un nombre aléatoire de 1-10

La formule est: valeur minimale ---- Nombre aléatoire de valeur maximale (intégrale)

(Type) min + math.random () * valeur maximale

Méthode 3

 Random RA = new Random (); for (int i = 0; i <30; i ++) {System.out.println (ra.nextint (10) +1);}

Utilisez la méthode NextInt de classe aléatoire dans le package java.util pour obtenir un nombre aléatoire int 1-10

Générer des décimales aléatoires entre 0 et 1:

Pour générer une décimale aléatoire dans l'intervalle [0, D) et D est toute décimale positive, il vous suffit de multiplier la valeur de retour de la méthode NextDouble par d.

[n1, n2]

C'est-à-dire ra.nextdouble () * (n2-n1) + n1

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 un certain nombre, par exemple, se multiplier par 100. C'est un aléatoire à moins de 100, qui n'existe pas dans J2Me.

2. Dans le package java.util, une classe aléatoire est fournie. Nous pouvons créer un nouvel objet aléatoire pour générer des nombres aléatoires. Il peut générer 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 le limiter à une plage.

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

La classe aléatoire de la méthode deux a la description suivante:

Il existe deux façons de construire la classe Java.util.Random: avec des graines et sans graines

Pas de graines:

Cette méthode renverra des nombres aléatoires et les résultats seront différents pour chaque exécution.

 classe publique RandomTest {public static void main (String [] args) {java.util.random r = new java.util.random (); for (int i = 0; i <10; i ++) {System.out.println (r.nextint ());}}

Avec des graines:

De cette façon, peu importe le nombre de fois que le programme s'exécute, le résultat de retour sera le même

 public static void main (String [] args) {java.util.random r = new java.util.random (10); for (int i = 0; i <10; i ++) {System.out.println (r.nextint ());}}

La différence entre les deux méthodes est

(1) Tout d'abord, veuillez ouvrir Java Doc, nous verrons la description de la classe aléatoire:

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. Pour nous assurer que cette fonctionnalité est implémentée, nous spécifions un algorithme spécifique pour la classe aléatoire. Pour la portabilité complète du code Java, les implémentations Java doivent avoir la classe aléatoire à utiliser tous les algorithmes affichés ici. Mais les sous-classes de classe aléatoire sont autorisées à utiliser d'autres algorithmes tant qu'elles sont conformes aux accords conventionnels de toutes les méthodes.

Java Doc a très bien expliqué la classe aléatoire, et nos tests l'ont vérifié.

(2) Si aucun nombre de semences n'est fourni, le nombre de graines de l'instance aléatoire sera les millisecondes de l'heure actuelle. Vous pouvez obtenir les millisecondes de l'heure actuelle via System.Currenttimemillis (). Ouvrez le code source de JDK et nous pouvons le voir très clairement.

 public random () {this (System.Currenttimemillis ()); }

en outre:

Description des méthodes NextInt (), NextInt (int n) de l'objet aléatoire:

int nextInt () // Renvoie le numéro de pseudo-aléatoire suivant, qui est la valeur int uniformément distribuée 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.

Java Random Number Résumé

Les nombres aléatoires sont largement utilisés dans la pratique, comme la génération d'une chaîne ou d'un nombre de longueur fixe. Soit générer ensuite un certain nombre de longueurs incertaines, soit effectuer une sélection aléatoire simulée, etc. Java fournit les outils les plus élémentaires qui peuvent aider les développeurs à réaliser tout cela.

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. Il s'agit d'une classe d'outils aléatoire professionnelle avec des fonctions puissantes.

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 utilise une formule congruent linéaire pour les modifier (voir l'art de la programmation informatique de Donald Knuth, volume 2, section 3.2.1).

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

Random () // Créez un nouveau générateur de nombres aléatoires.

Random (graine longue) // Créez un nouveau générateur de nombres aléatoires en utilisant une seule graine longue: public aléatoire (graine longue) {SetSeed (semence); } 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ère le numéro de pseudo-aléatoire suivant.

Boolean NextBoolean (): Renvoie le prochain numéro de pseudo-aléatoire, qui est la valeur booléenne uniformément répartie tirée de la séquence de ce générateur de nombres aléatoires.

void NextBytes (octets [] octets): génère des octets aléatoires et les place dans un tableau d'octets fourni par l'utilisateur.

Double NextDouble (): Renvoie le numéro de pseudo-aléatoire suivant, qui est réparti uniformément 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 de 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 NEXTGAUSSIAN (): Renvoie le prochain numéro pseudo-aléatoire, qui est une distribution gaussienne ("normalement") tirée de la séquence de ce générateur de nombres aléatoires, avec une valeur moyenne de 0,0 et un écart-type de 1,0.

int nextInt (): renvoie le prochain numéro pseudo-aléatoire, qui est la valeur intymétrique uniformément distribuée 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 une valeur intrusée uniformément répartie à partir de la séquence de ce générateur de nombres aléatoires et est uniformément distribué entre 0 (y compris) et la valeur spécifiée (à l'exclusion).

Long NextLong (): Renvoie le numéro de 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 setseed (graine longue): définit la graine de ce générateur de nombres aléatoires en utilisant une seule graine longue.

3. Instructions d'utilisation de classe aléatoire

1. La différence entre prendre des graines et ne pas prendre de graines. L'utilisation fondamentale de la classe aléatoire est de diviser les exemples de hasard avec des graines et sans graines.

En termes de laïque, la différence entre les deux est: si les graines sont produites, les résultats générés par chaque course sont les mêmes.

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. Il existe deux façons de créer un objet aléatoire sans graines:

1) aléatoire aléatoire = nouveau aléatoire (555L);

2) aléatoire aléatoire = nouveau aléatoire (); random.setseed (555L);

4. Test

Utilisez un exemple pour illustrer l'utilisation ci-dessus

 import java.util.random; classe publique TestRandomNum {public static void main (String [] args) {randomtest (); testnoseed (); TestSeed1 (); TestSeed2 (); } public static void randomtest () { System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------  long R1 = System.Currenttimemillis (); System.out.println ("R2 =" + R3); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- for (int i = 0; i <3; i ++) {System.out.println (random.nextint ()); }} public static void testseed1 () { System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Résultats en cours:

--------------test()--------------
R1 = 1227108626582
R3 = 0,5324887850155043
R2 = -368083737
-------------- testnoseed () --------------
809503475
1585541532
-645134204
-------------- TestSeed1 () --------------
-1367481220
292886146
-1462441651
-------------- TestSeed2 () --------------
-1367481220
292886146
-1462441651
Processus terminé avec le code de sortie 0

Grâce aux résultats des méthodes TestSeed1 () et TestSeed2 (), nous pouvons voir que les deux résultats d'impression sont les mêmes car ils voient les mêmes. S'ils courent à nouveau, le résultat sera toujours le même. C'est la caractéristique des nombres aléatoires avec des graines. Si vous n'avez pas de graines, les résultats de chaque course sont aléatoires.

V. Application complète

Ce qui suit est une classe d'outils aléatoires récemment écrite pour afficher l'utilisation:

 import java.util.random; classe publique RandomUtils {public static final string allchar = "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; public static final string wetterchar = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; Public static final string numéroChar = "0123456789"; public static String generateString (int longueur) {stringBuffer sb = new StringBuffer (); Aléatoire aléatoire = nouveau aléatoire (); for (int i = 0; i <length; i ++) {sb.append (allchar.charat (random.nextint (allchar.length ()))); } return sb.toString (); } public static String generateMixString (int longueur) {stringBuffer sb = new StringBuffer (); Aléatoire aléatoire = nouveau aléatoire (); for (int i = 0; i <length; i ++) {sb.append (allchar.charat (random.nextint (LetterChar.Length ()))); } return sb.toString (); } public static String generateLowerString (int longueur) {return generateMixString (longueur) .tolowerCase (); } public static String generateupperString (int longueur) {return generateMixString (longueur) .touppercase (); } public static String generateLeroString (int longueur) {stringBuffer sb = new StringBuffer (); pour (int i = 0; i <length; i ++) {sb.append ('0'); } return sb.toString (); } public static String tofixdLengthStHstring (long num, int fixdLenth) {stringBuffer sb = new StringBuffer (); String strnum = string.valueof (num); if (fixdLenth - strnum.length ()> = 0) {sb.append (generateZeroString (fixdlenth - strnum.length ())); } else {Throw New RuntimeException ("Convert Number" + num + "L'exception se produit lorsqu'une exception est faite en une chaîne avec une longueur" + fixdlenth + ");} SB.APPEND (strNum); return sb.tostring ();} stringbuffer static tofixdlengthString (int num, int fixdlenth) {stringbuffer sb = new StringbUffer (); String STRNUM = String.valueof (num); } sb.append (strnum); return sb.toString (); } public static void main (String [] args) {System.out.println (generateString (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)); 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 couramment utilisés. Il existe trois façons de les générer en Java. Les nombres aléatoires aléatoires sont les plus complexes.

2. Les objets de classe aléatoire ont une différence entre s'ils transportent des graines. Tant que les graines sont les mêmes, elles fonctionnent plusieurs fois et le résultat de la génération de nombres aléatoires est toujours le même.

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.

En Java, nous pouvons utiliser la classe java.util.random pour générer un générateur de nombres aléatoires. Il a deux formes de constructeurs, à savoir aléatoire () et aléatoire (graine longue). Random () utilise l'heure actuelle, System.Currenttimemillis (), comme graine du générateur, et aléatoire (graine longue) utilise la graine spécifiée comme graine du générateur.

Une fois l'objet générateur de nombres aléatoires (aléatoire), différents types de nombres aléatoires sont obtenus en appelant différentes méthodes: NextInt (), nextLong (), nextFloat (), nextDouble (), etc.

1> Générer des nombres aléatoires

 Aléatoire aléatoire = nouveau aléatoire (); Aléatoire aléatoire = nouveau aléatoire (100); // spécifie le nombre de graines 100

Random appelle différentes méthodes pour obtenir des nombres aléatoires.

Si 2 objets aléatoires utilisent la même graine (par exemple, les deux sont 100) et que la même fonction est appelée dans le même ordre, leurs valeurs de retour sont exactement les mêmes. Comme dans le code suivant, la sortie des deux objets aléatoires est exactement le même

 import java.util. *; classe TestRandom {public static void main (String [] args) {random random1 = new random (100); System.out.println (random1.nextint ()); System.out.println (random1.nextfloat ()); System.out.println (random1.nextBoolean ()); Random random2 = nouveau aléatoire (100); System.out.println (random2.Nextint ()); System.out.println (random2.NextFloat ()); System.out.println (random2.NextBoolean ()); }}

2> nombres aléatoires dans la plage spécifiée

Les nombres aléatoires sont contrôlés dans une certaine plage, en utilisant l'opérateur de module%

 import java.util. *; classe TestRandom {public static void main (String [] args) {random random = new random (); for (int i = 0; i <10; i ++) {System.out.println (math.abs (random.nextint ())); }}}

Les nombres aléatoires obtenus sont positifs et négatifs. Utilisez Math.Abs pour faire récupérer la plage de données en tant que nombres non négatifs.

3> Obtenez des nombres aléatoires non réactives dans la plage spécifiée

 import java.util. *; classe TestRandom {public static void main (String [] args) {int [] intret = new int [6]; intrd = 0; // Nombres aléatoires de stockage int count = 0; // Enregistrez les nombres aléatoires générés int flag = 0; // si le drapeau a été généré pendant (comte <6) {Random rdm = new Random (System.currentTimemillis ()); intrd = math.abs (rdm.Nextint ()) 2 + 1; for (int i = 0; i <count; i ++) {if (intret [i] == intrd) {flag = 1; casser; } else {flag = 0; }} if (flag == 0) {intret [count] = intrd; Count ++; }} pour (int t = 0; t <6; t ++) {System.out.println (t + "->" + intret [t]); }}}

Les nombres aléatoires en Java peuvent-ils être répétés? Les nombres aléatoires générés en Java peuvent-ils être utilisés pour générer des clés primaires de base de données? Avec cette question à l'esprit, nous avons fait une série de tests.

1. Test 1: Utilisez le constructeur aléatoire () sans paramètres

 classe publique RandomTest {public static void main (String [] args) {java.util.random r = new java.util.random (); pour (int i = 0; i <10; i ++) {System.out.println (r.Nextint ()); }}}

Résultats du programme en cours d'exécution:

-1761145445
-1070533012
216216989
-910884656
-1408725314
-1091802870
1681403823
-1099867456
347034376
-1277853157

Exécutez à nouveau le programme:

-169416241
220377062
-1140589550
-1364404766
-1088116756
2134626361
-546049728
1132916742
-1522319721
1787867608

D'après le test ci-dessus, nous pouvons voir que les nombres aléatoires générés en utilisant le constructeur aléatoire () sans paramètres ne seront pas répétés. Donc, dans quelles circonstances Java produit-elle des nombres aléatoires en double? Voyons le test ci-dessous.

2. Test 2: Définissez le nombre de graines pour aléatoire

 classe publique RandomTest_Repeat {public static void main (String [] args) {java.util.random r = new java.util.random (10); pour (int i = 0; i <10; i ++) {System.out.println (r.Nextint ()); }}}

Peu importe combien de fois le programme fonctionne, le résultat est toujours:

-1157793070
1913984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428

Même si vous le testez sur différentes machines, les résultats du test ne changent pas!

3. Analyse de cause:

(1) Tout d'abord, veuillez ouvrir Java Doc, nous verrons la description de la classe aléatoire:

Des exemples de cette classe sont utilisés pour générer des flux de nombres pseudo-aléatoires, qui utilisent une graine 48 bits qui peut être modifiée à l'aide d'une formule congruente linéaire (voir l'art de la programmation informatique de Donald Knuth, Volume 2, section 3.2.1).

Java Doc a très bien expliqué la classe aléatoire, et nos tests l'ont vérifié.

 public random () {this (System.Currenttimemillis ()); }

4. Conclusion:

Grâce aux tests et à l'analyse ci-dessus, nous aurons une compréhension plus profonde de la classe aléatoire. Dans le même temps, je pense qu'en lisant la documentation de l'API Java Doc, nos capacités de programmation Java peuvent être considérablement améliorées et «connaître la vérité» peut être réalisée; Une fois que nous rencontrons des problèmes perplexes, nous pourrions aussi bien ouvrir le code source Java afin que nous puissions "connaître la vérité".

Il existe généralement deux types de nombres aléatoires dans Java, l'un est la méthode aléatoire () en mathématiques, et l'autre est la classe aléatoire.

1. Math.Random ()

Un nombre décimal de 0 <x <1 est généré.

Exemple: comment écrire et générer au hasard l'un des nombres de 0 à 100?

Math.Random () ne renvoie qu'une décimale de 0 à 1. Si vous voulez 50 à 100, vous zoomerez 50 fois en premier, c'est-à-dire entre 0 et 50. Voici toujours une décimale. Si vous voulez un entier, vous allez lancer INT, puis ajouter 50 à 50 à 100.

Code final: (int) (math.random () * 50) + 50

2. Classe aléatoire

 Random Random = new Random (); // Constructeur par défaut aléatoire aléatoire = nouveau aléatoire (1000); // spécifiez le nombre de semences

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.

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:

A, public boolean 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%.

B, public double nextDouble ()

Le but de cette méthode est de générer une double valeur aléatoire, la valeur se situe entre [0, 1.0). Ici, les supports représentent les points d'extrémité contenant l'intervalle, et les supports représentent les points d'extrémité qui n'incluent pas l'intervalle, c'est-à-dire une décimale aléatoire entre 0 et 1, contenant 0 mais pas 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 la 31e puissance de -2 et 31e puissance de -1e puissance de 2.

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)

 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)

 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 le nombre décimal [n1, n2] de l'intervalle [1, 2,5) [1]

Double D3 = R.NextDouble () * 1,5 + 1; 【c'est-à-dire R.NextDouble () * (N2-N1) + N1】

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

 int n1 = r.Nextint ();

Utilisez simplement la méthode NextInt directement.

e. Générer des entiers dans l'intervalle [0,10)

 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 du nombre 10 est (-10,10), car selon la spécification mathématique, la valeur absolue du reste est inférieure au diviseur, puis la valeur absolue de l'intervalle est calculée, et l'intervalle résultant 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:

 int n2 = r.Nextint (n); n2 = math.abs (r.Nextint ()% n);

f. Générer des entiers dans l'intervalle [0,10]

 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)

 int n4 = r.Nextint (18) - 3; // 【c'est-à-dire r.nextint () * (n2-n1) + n1】 n1 est un nombre négatif 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.

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.