Es führt hauptsächlich drei Methoden zur Erlangung von Zufallszahlen in Java ein, wobei hauptsächlich die Funktion random () verwendet wird, um sie zu implementieren
Methode 1
(Datentyp) (Minimalwert + Math.Random ()*(Maximalwert -Minimum -Wert +1)) Beispiel:
(int) (1+math.random ()*(10-1+1))
Int Typ von 1 bis 10
Methode 2
Eine Zufallszahl erhalten
für (int i = 0; i <30; i ++) {System.out.println ((int) (1+math.random ()*10));} (int) (1+math.random ()*10) Die zufällige Methode des Java.math-Pakets erhält eine int-zufällige Anzahl von 1-10
Die Formel lautet: Mindestwert ---- Zufällige Anzahl des Maximalwerts (integral)
(Typ) min + math.random () * Maximaler Wert
Methode 3
Random ra = new random (); für (int i = 0; i <30; i ++) {System.out.println (ra.Nextint (10) +1);} Verwenden Sie die nächste Methode der zufälligen Klasse im Java.util-Paket, um eine int-zufällige Anzahl von 1-10 zu erhalten
Generieren Sie zufällige Dezimalstellen zwischen 0 und 1:
Um eine zufällige Dezimalzahl im Intervall zu erzeugen [0, d) und D ist eine positive Dezimalzahl, müssen Sie nur den Rückgabewert der NextDouble -Methode mit d multiplizieren.
[N1, N2]
Das ist ra.nextDouble () * (n2-n1)+n1
Verschiedene Möglichkeiten, um zufällige Zahlen in Java zu generieren
1. In J2SE können wir die Methode Math.Random () verwenden, um eine Zufallszahl zu generieren. Die erzeugte Zufallszahl ist ein Doppel zwischen 0-1. Wir können es mit einer bestimmten Zahl multiplizieren, z. B. mit 100 multiplizieren. Es ist ein zufälliges innerhalb von 100, der in J2ME nicht existiert.
2. Im Java.util -Paket wird eine zufällige Klasse bereitgestellt. Wir können ein neues zufälliges Objekt erstellen, um zufällige Zahlen zu generieren. Es kann zufällige Ganzzahlen, zufällige Floats, zufällige Doppel und zufällige lange erzeugen. Dies ist auch eine Methode, um zufällige Zahlen einzunehmen, die wir häufig in J2ME -Programmen verwenden.
3.. In unserer Systemklasse befindet sich eine CurrentItimemillis () -Methode. Diese Methode gibt eine Millisekunden -Nummer von 0:00:00 am 1. Januar 1970 auf die aktuelle zurück. Der Rückgabetyp ist lang. Wir können es als Zufallszahl verwenden. Wir können es verwenden, um einige Zahlen zu modeln und auf einen Bereich zu beschränken.
Tatsächlich wird bei der Standardkonstruktionsmethode von Random die obige dritte Methode zur Erzeugung von Zufallszahlen verwendet.
Die zufällige Klasse in Methode zwei hat die folgende Beschreibung:
Es gibt zwei Möglichkeiten, die Java.util.Random -Klasse zu bauen: mit Samen und ohne Samen
Keine Samen:
Diese Methode gibt zufällige Zahlen zurück und die Ergebnisse sind für jeden Lauf unterschiedlich.
public class randomTest {public static void main (String [] args) {java.util.random r = new Java.util.random (); für (int i = 0; i <10; i ++) {System.out.println (R.Nextint ());}}}}}}}}}} Mit Samen:
Auf diese Weise wird das Rückgabeergebnis das gleiche sein, egal wie oft das Programm ausgeführt wird
public static void main (String [] args) {java.util.random r = new java.util.random (10); für (int i = 0; i <10; i ++) {System.out.println (R.Nextint ());}}} Der Unterschied zwischen den beiden Methoden ist
(1) Bitte öffnen Sie Java Doc, wir werden die Beschreibung der zufälligen Klasse sehen:
Beispiele für diese Klasse werden verwendet, um Pseudo-Random-Zahlenströme zu generieren, die einen 48-Bit-Samen verwenden, der unter Verwendung einer linearen kongruenten Formel geändert werden kann.
Wenn zwei zufällige Instanzen mit demselben Samen erstellt werden, wird dieselbe Abfolge von Methodenaufrufen für jede Instanz erstellt und die gleiche Abfolge von Zahlen erzeugt und zurückgibt. Um sicherzustellen, dass diese Funktion implementiert ist, geben wir einen bestimmten Algorithmus für die Klasse zufällig an. Für die vollständige Portabilität des Java -Code müssen Java -Implementierungen die Klasse zufällig alle hier angezeigten Algorithmen verwenden. Unterklassen der zufälligen Klasse dürfen jedoch andere Algorithmen verwenden, solange sie den herkömmlichen Vereinbarungen aller Methoden entsprechen.
Java Doc hat die zufällige Klasse sehr gut erklärt, und unsere Tests haben dies überprüft.
(2) Wenn keine Samenzahl bereitgestellt wird, sind die Anzahl der Samen der zufälligen Instanz die Millisekunden der aktuellen Zeit. Sie können die Millisekunden der aktuellen Zeit über System.currentTimemillis () erhalten. Öffnen Sie den Quellcode von JDK und wir können dies sehr deutlich sehen.
public random () {this (System.currentTimemillis ()); } Zusätzlich:
Beschreibung der NextInt (), NextInt (int n) Methoden des zufälligen Objekts:
Int NextInt () // gibt die nächste Pseudo-Random-Zahl zurück, die der gleichmäßig verteilte Int-Wert in der Reihenfolge dieses Zufallszahlengenerators ist.
Int NextInt (int n) // gibt eine Pseudo-Random-Nummer zurück, die ein int-Wert ist, der gleichmäßig zwischen 0 (einschließlich) und dem angegebenen Wert (ausgenommen) aus der Reihenfolge dieses Zufallszahlengenerators entnommen wird.
Java -Zufallszahlenzusammenfassung
In der Praxis werden zufällige Zahlen häufig verwendet, z. B. eine Zeichenfolge oder Zahl mit fester Länge. Erstellen Sie entweder eine Reihe unsicherer Länge oder führen Sie eine simulierte zufällige Auswahl usw. durch. Java bietet die grundlegendsten Tools, mit denen Entwickler all dies erreichen können.
1. So generieren Sie zufällige Java -Zahlen
In Java gibt es drei allgemeine Konzepte von Zufallszahlen.
1. Verwenden Sie System.
2. RECHTEN SIE EINEN DOUBLEMALTEN zwischen 0 und 1 durch Math.Random ().
3. Generieren Sie eine Zufallszahl durch die zufällige Klasse. Dies ist eine professionelle zufällige Werkzeugkurs mit leistungsstarken Funktionen.
2. Zufällige API -Beschreibung
1. Java API Beschreibung
Eine Instanz der zufälligen Klasse wird verwendet, um einen Pseudo-Random-Zahlenstrom zu generieren. Diese Klasse verwendet 48-Bit-Samen und eine lineare kongruente Formel, um sie zu ändern (siehe Donald Knuths The Art of Computer Programing, Band 2, Abschnitt 3.2.1).
Wenn zwei zufällige Instanzen mit demselben Samen erstellt werden, wird dieselbe Abfolge von Methodenaufrufen für jede Instanz erstellt und die gleiche Abfolge von Zahlen erzeugt und zurückgibt. Um die Implementierung von Attributen zu gewährleisten, wird für die Klasse zufällig ein spezifischer Algorithmus angegeben.
Viele Anwendungen finden die zufällige Methode in der Mathematikklasse leichter zu verwenden.
2. Zusammenfassung der Methode
Random () // Erstellen Sie einen neuen Zufallszahlengenerator.
Zufälliger (langer Saatgut) // Erstellen Sie einen neuen Zufallszahlengenerator mit einem einzigen langen Samen: öffentlicher zufälliger (langer Samen) {SetSeed (Samen); } In der nächsten Methode speichert sie den Status des Zufallszahlengenerators.
Protected Int Next (int Bits): Erzeugt die nächste Pseudo-Random-Nummer.
Boolean NextBoolean (): Gibt die nächste Pseudo-Random-Nummer zurück, die der gleichmäßig verteilte Boolesche Wert ist, der aus der Abfolge dieses Zufallszahlengenerators entnommen wurde.
void NextBytes (Byte [] Bytes): Erzeugt zufällige Bytes und platziert sie in ein von Benutzer bereitgestellter Byte-Array.
Double NextDouble (): Gibt die nächste Pseudo-Random-Zahl zurück, die ein Doppelwert gleichmäßig zwischen 0,0 und 1,0 ist, der aus der Abfolge dieses Zufallszahlengenerators entnommen wird.
Float Nextfloat (): Gibt die nächste Pseudo-Random-Zahl zurück, die ein Float-Wert ist, der gleichmäßig zwischen 0,0 und 1,0 aus der Sequenz dieses Zufallszahlengenerators entnommen wird.
Double NextGaussian (): Gibt die nächste Pseudo-Random-Zahl zurück, eine Gaußsche ("normal") Verteilung, die aus der Abfolge dieses Zufallszahlengenerators mit einem Durchschnittswert von 0,0 und einer Standardabweichung von 1,0 entnommen wird.
INT NextInt (): Gibt die nächste Pseudo-Random-Zahl zurück, die der gleichmäßig verteilte Int-Wert in der Reihenfolge dieses Zufallszahlengenerators ist.
Int NextInt (int n): Gibt eine Pseudo-Random-Zahl zurück, die ein gleichmäßig verteiltes int-Wert ist, der aus der Reihenfolge dieses Zufallszahlengenerators entnommen wird und zwischen 0 (einschließlich) und dem angegebenen Wert (mit Ausnahme) einheitlich verteilt ist.
Long Nextlong (): Gibt die nächste Pseudo-Random-Zahl zurück, die ein einheitlich verteilter langer Wert ist, der aus der Abfolge dieses Zufallszahlengenerators entnommen wird.
Hohlraum Setseed (Long Seed): Setzt den Samen dieses Zufallszahlengenerators mit einem einzigen langen Samen.
3. Anweisungen für zufällige Klassennutzung
1. Der Unterschied zwischen Samen und nicht Samen. Die grundlegende Verwendung von zufälliger Klasse besteht darin, die Beispiele von zufällig mit Samen und ohne Samen zu teilen.
In den Laiengründen beträgt der Unterschied zwischen den beiden: Wenn die Samen erzeugt werden, sind die Ergebnisse, die von jedem Lauf erzeugt werden, gleich.
Wenn Sie keine Samen haben, ist das, was Sie generieren, jedes Mal, wenn Sie laufen, zufällig und es gibt überhaupt kein Muster.
2. Erstellen Sie ein zufälliges Objekt ohne Samen
Random random = new random ();
3.. Es gibt zwei Möglichkeiten, ein zufälliges Objekt ohne Samen zu erstellen:
1) zufälliges zufälliger = neuer zufälliger (555L);
2) Random Random = New Random (); Random.SeetSeed (555L);
4. Test
Verwenden Sie ein Beispiel, um die obige Verwendung zu veranschaulichen
import Java.util.random; public class testrandomnum {public static void main (String [] args) {randomTest (); testNoseed (); testSeed1 (); testseed2 (); } public static void randomTest () { System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- long r1 = system.currentTimillis (); System.out.println ("R2 =" + R3); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Random(); für (int i = 0; i <3; i ++) {System.out.println (random.nextint ()); }} public static void testseed1 () { System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Auslaufergebnisse:
--------------prüfen()--------------
R1 = 1227108626582
R3 = 0,5324887850155043
R2 = -368083737
-------------- TestNoseed () ------------------
809503475
1585541532
-645134204
-------------- testseed1 () ------------------
-1367481220
292886146
-1462441651
-------------- testseed2 () ------------------
-1367481220
292886146
-1462441651
Vorgang mit dem Ausgangscode 0 abgeschlossen
Durch die Ergebnisse der Methoden testSeed1 () und testseed2 () können wir feststellen, dass die beiden Druckergebnisse gleich sind, da sie dasselbe sehen. Wenn sie wieder laufen, ist das Ergebnis immer noch das gleiche. Dies ist das Merkmal von Zufallszahlen mit Samen. Wenn Sie keine Samen haben, sind die Ergebnisse jedes Laufs zufällig.
V. umfassende Anwendung
Das Folgende ist eine kürzlich geschriebene Toolklasse für Zufallszahlen, um die Nutzung anzuzeigen:
import Java.util.random; public class randomutils {public static final String AllChar = "0123456789abcdefghijklMnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; public static Final String Letterchar = "AbcDefghijklMnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; public static final String numberchar = "0123456789"; public static String generatestring (int länge) {stringBuffer sb = new StringBuffer (); Random random = new random (); für (int i = 0; i <länge; i ++) {sb.append (AllChar.Charat (random.Nextint (allChar.Length ()))); } return sb.toString (); } public static String GeneratemixString (int Länge) {StringBuffer sb = new StringBuffer (); Random random = new random (); für (int i = 0; i <länge; i ++) {sb.Append (AllChar.Charat (random.Nextint (Letterchar.Length ()))); } return sb.toString (); } public static String GeneratEloWerString (int Länge) {return GeneratemixString (Länge) .TolowerCase (); } public static String generateUpperString (int länge) {return GeneratemixString (Länge) .ToUpperCase (); } public static String generatezeroString (int länge) {stringBuffer sb = new StringBuffer (); für (int i = 0; i <länge; i ++) {sb.append ('0'); } return sb.toString (); } public static String tofixDLengthString (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 {throf New RunTimeException ("Number" + num + "Ausnahme tritt auf, wenn eine Ausnahme an eine Zeichenfolge mit Länge" + FixDlenth + ");} SB.Append (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 (GenerateloWerString (15)); System.out.println (GenerateUpperString (15)); System.out.println (GeneratezerOstring (15)); System.out.println (TofixDLengthString (123, 15)); System.out.println (TofixDLengthString (123L, 15)); System.out.println (TofixDLengthString (123L, 15)); }}Auslaufergebnisse:
vwmbpinbzfgcPhg
23Hyrahdjkkpwmv
Tigowetbwkm1nde
Bpz1nejphb115n
0000000000000000
000000000000123
000000000000123
Vorgang mit dem Ausgangscode 0 abgeschlossen
6. Zusammenfassung
1. Zufällige Zahlen werden sehr häufig verwendet. Es gibt drei Möglichkeiten, sie in Java zu generieren. Zufällige Zufallszahlen sind die komplexesten.
2. Zufallsklassenobjekte haben einen Unterschied zwischen dem Tragen von Samen. Solange die Samen gleich sind, laufen sie mehrmals und das Ergebnis der Erzeugung von Zufallszahlen ist immer gleich.
3.. Es gibt zwei Möglichkeiten, Saatgutobjekte mit zufälligen Zahlen mit dem gleichen Effekt zu erstellen. Aber zufällige Zahlen mit Samen scheinen nicht nützlich zu sein.
V.
5. Sie können zufällige Zahlen verwenden, um komplexe Zufallsdaten wie zufällige Zeichenfolgen zu implementieren.
6. Studieren Sie keine zufälligen Zahlen, die sich nicht wiederholen, sondern ist nicht sehr aussagekräftig.
In Java können wir die Klasse Java.util.Random verwenden, um einen Zufallszahlengenerator zu generieren. Es hat zwei Formen von Konstruktoren, nämlich zufällig () und zufällige (lange Samen). Random () verwendet die aktuelle Zeit, system.currentTimemillis () als Samen des Generators und zufälliger (langer Samen) den angegebenen Samen als Samen des Generators.
Nachdem das Objekt des Zufallszahlengenerators (zufällig) erstellt wurde, werden verschiedene Arten von Zufallszahlen erhalten, indem verschiedene Methoden aufgerufen werden: NextInt (), Nextlong (), Nextfloat (), NextDouble () usw.
1> Zufallszahlen generieren
Random random = new random (); Random zufällig = neu zufällig (100); // Geben Sie die Anzahl der Samen 100 an 100 an
Zufällige Aufrufe verschiedener Methoden, um zufällige Zahlen zu erhalten.
Wenn 2 zufällige Objekte denselben Saatgut verwenden (z. B. beide 100) und dieselbe Funktion in derselben Reihenfolge aufgerufen wird, sind ihre Rückgabestalte genau gleich. Wie im folgenden Code ist die Ausgabe der beiden zufälligen Objekte genau gleich
import Java.util.*; Klasse testrandom {public static void main (String [] args) {random random11 = new random (100); System.out.println (random1.nextint ()); System.out.println (random1.nextfloat ()); System.out.println (random1.nextboolean ()); Random Random2 = New Random (100); System.out.println (random22.nextint ()); System.out.println (random22.nextfloat ()); System.out.println (random22.nextboolean ()); }} 2> Zufallszahlen im angegebenen Bereich
Zufallszahlen werden in einem bestimmten Bereich unter Verwendung des Modul -Operator % kontrolliert
import Java.util.*; class testrandom {public static void main (String [] args) {randal random = new randal (); für (int i = 0; i <10; i ++) {System.out.println (math.abs (random.Nextint ())); }}}Die erhaltenen Zufallszahlen sind positiv und negativ. Verwenden Sie Math.Abs, um den Datenbereich als nicht negative Zahlen abzurufen.
3> Nicht repetitive Zufallszahlen innerhalb des angegebenen Bereichs erhalten
import Java.util.*; Klasse testrandom {public static void main (String [] args) {int [] intret = new int [6]; intrd = 0; // Zufallsnummern int count = 0; // Aufzeichnen Sie die generierten Zufallszahlen int flag = 0; // ob das Flag generiert wurde, während (count <6) {Random rdm = new random (System.currentTimemillis ()); intrd = math.abs (rdm.NextInt ()) 2+1; für (int i = 0; i <count; i ++) {if (intret [i] == intrd) {flag = 1; brechen; } else {flag = 0; }} if (flag == 0) {intret [count] = intrad; zählen ++; }} für (int t = 0; t <6; t ++) {System.out.println (t+"->"+intret [t]); }}} Können zufällige Zahlen in Java wiederholt werden? Können zufällige Zahlen in Java verwendet werden, um Datenbank -Primärschlüssel zu generieren? Mit dieser Frage haben wir eine Reihe von Tests durchgeführt.
1. Test 1: Verwenden Sie den random () -Konstruktor ohne Parameter
public class randomTest {public static void main (String [] args) {java.util.random r = new java.util.random (); für (int i = 0; i <10; i ++) {System.out.println (r.NextInt ()); }}} Programmauslaufergebnisse:
-1761145445
-1070533012
216216989
-910884656
-1408725314
-1091802870
1681403823
-1099867456
347034376
-1277853157
Führen Sie das Programm erneut aus:
-169416241
220377062
-1140589550
-1364404766
-1088116756
2134626361
-546049728
1132916742
-1522319721
1787867608
Aus dem obigen Test können wir sehen, dass die zufälligen Zahlen, die mit dem Random () -Konstruktor ohne Parameter generiert werden, nicht wiederholt werden. Unter welchen Umständen erzeugt Java also doppelte Zufallszahlen? Lassen Sie uns den folgenden Test sehen.
2. Test 2: Stellen Sie die Anzahl der Samen für zufällig ein
public class randomTest_repeat {public static void main (String [] args) {java.util.random r = new java.util.random (10); für (int i = 0; i <10; i ++) {System.out.println (r.NextInt ()); }}} Unabhängig davon, wie oft das Programm ausgeführt wird, ist das Ergebnis immer:
-1157793070
1913984760
1107254586
1773446580
254270492
-1408064384
1048475594
1581279777
-778209333
1532292428
Selbst wenn Sie es auf verschiedenen Maschinen testen, ändern sich die Testergebnisse nicht!
3. Ursache Analyse:
(1) Bitte öffnen Sie Java Doc, wir werden die Beschreibung der zufälligen Klasse sehen:
Beispiele für diese Klasse werden verwendet, um Pseudo-Random-Zahlenströme zu generieren, die einen 48-Bit-Saatgut verwenden, der mithilfe einer linearen kongruenten Formel geändert werden kann (siehe Donald Knuths The Art of Computer Programing, Band 2, Abschnitt 3.2.1).
Wenn zwei zufällige Instanzen mit demselben Samen erstellt werden, wird dieselbe Abfolge von Methodenaufrufen für jede Instanz erstellt und die gleiche Abfolge von Zahlen erzeugt und zurückgibt. Um sicherzustellen, dass diese Funktion implementiert ist, geben wir einen bestimmten Algorithmus für die Klasse zufällig an. Für die vollständige Portabilität des Java -Code müssen Java -Implementierungen die Klasse zufällig alle hier angezeigten Algorithmen verwenden. Unterklassen der zufälligen Klasse dürfen jedoch andere Algorithmen verwenden, solange sie den herkömmlichen Vereinbarungen aller Methoden entsprechen.
Java Doc hat die zufällige Klasse sehr gut erklärt, und unsere Tests haben dies überprüft.
(2) Wenn keine Samenzahl bereitgestellt wird, sind die Anzahl der Samen der zufälligen Instanz die Millisekunden der aktuellen Zeit. Sie können die Millisekunden der aktuellen Zeit über System.currentTimemillis () erhalten. Öffnen Sie den Quellcode von JDK und wir können dies sehr deutlich sehen.
public random () {this (System.currentTimemillis ()); } 4. Schlussfolgerung:
Durch die oben genannten Tests und Analysen werden wir die zufällige Klasse ein tieferes Verständnis haben. Gleichzeitig denke ich, dass unsere Java -Programmierfunktionen durch das Lesen der Dokumentation von Java Doc API erheblich verbessert werden können und "die Wahrheit wissen" erreicht werden kann. Sobald wir auf verwirrte Probleme stoßen, können wir den Java -Quellcode genauso gut öffnen, damit wir "die Wahrheit kennen" können.
In Java gibt es im Allgemeinen zwei Arten von Zufallszahlen, eine ist die zufällige () -Methode in Mathematik und die andere ist die zufällige Klasse.
1. Math.Random ()
Eine Dezimalzahl von 0 <x <1 wird generiert.
Beispiel: Wie schreibe und generiere ich zufällig eine der Zahlen von 0 bis 100?
Math.random () gibt nur ein Dezimaler von 0 bis 1 zurück. Wenn Sie 50 bis 100 möchten, zoomen Sie zuerst das 50 -mal. Wenn Sie eine Ganzzahl wollen, werden Sie int int werfen und dann 50 bis 50 bis 100 hinzufügen.
Endgültiger Code: (int) (math.random ()*50) + 50
2. Zufällige Klasse
Randal randomall = new random (); // Standardkonstruktor Random Random = New Random (1000); // Saatgutnummer angeben
Bei der Randomisierung wird die Anzahl der Herkunft des Zufallsalgorithmus als Samen bezeichnet, was eine bestimmte Transformation basierend auf den Samen durchführt, wodurch die erforderlichen Zufallszahlen erzeugt werden.
Zufällige Objekte mit der gleichen Anzahl von Samen, die zufälligen Zahlen, die nach der gleichen Häufigkeit generiert werden, sind genau gleich. Mit anderen Worten, für zwei zufällige Objekte mit derselben Samenzahl sind die zum ersten Mal generierten Zufallszahlen genau gleich und die zum zweiten Mal generierten Zufallszahlen sind genau gleich.
2. Gemeinsame Methoden in der zufälligen Klasse
Die Methoden in der zufälligen Klasse sind relativ einfach und die Funktionen jeder Methode sind ebenfalls leicht zu verstehen. Es ist zu beachten, dass die von jeder Methode in der Zufallsklasse erzeugten Zufallszahlen einheitlich verteilt sind, was bedeutet, dass die Wahrscheinlichkeit der numerischen Erzeugung innerhalb des Intervalls gleich ist. Hier ist eine grundlegende Einführung in diese Methoden:
A, öffentlicher Boolean Nextboolean ()
Die Funktion dieser Methode besteht darin, einen zufälligen booleschen Wert zu erzeugen, und die Wahrscheinlichkeit, echte und falsche Werte zu erzeugen, ist gleich, dh beides beträgt 50%.
B, öffentliches Double NextDouble ()
Der Zweck dieser Methode ist es, einen zufälligen Doppelwert zu erzeugen, der Wert zwischen [0, 1.0). Hier repräsentieren die Klammern die Endpunkte, die das Intervall enthalten, und die Klammern repräsentieren die Endpunkte, die das Intervall nicht enthalten, dh eine zufällige Dezimalzahl zwischen 0 und 1, die 0, aber nicht 1,0 enthält.
C, public int NextInt ()
Der Zweck dieser Methode ist es, einen zufälligen Int -Wert zu erzeugen, der zwischen der 31. Leistung von -2 und 31. Leistung von -1. Leistung von 2 liegt.
Wenn Sie einen int -Wert für ein bestimmtes Intervall generieren müssen, müssen Sie eine bestimmte mathematische Transformation durchführen. Weitere Informationen finden Sie im folgenden Verwendungsbeispiel.
d, öffentlich int Nextint (int n)
Die Funktion dieser Methode besteht darin, einen zufälligen Int -Wert zu erzeugen, der sich innerhalb des Intervalls von [0, n) befindet, dh einen zufälligen Int -Wert zwischen 0 und n, der 0, aber nicht n enthält.
Wenn Sie einen int -Wert für ein bestimmtes Intervall generieren möchten, müssen Sie auch eine bestimmte mathematische Transformation durchführen. Weitere Informationen finden Sie im folgenden Verwendungsbeispiel.
E, öffentliche Leere Setseed (langer Samen)
Der Zweck dieser Methode besteht darin, die Anzahl der Samen im zufälligen Objekt zurückzusetzen. Nach dem Einstellen der Anzahl der Samen entspricht das zufällige Objekt dem mit dem neuen Schlüsselwort erstellten zufälligen Objekt.
3. Beispiel für zufällige Klasse -Nutzungsbeispiele
Unter Verwendung der zufälligen Klasse soll im Allgemeinen Zufallszahlen für ein bestimmtes Intervall generiert werden. Im Folgenden werden zufällige Zahlen für ein entsprechendes Intervall nacheinander generiert. Die folgenden Codes, die zufällige Zahlen generieren, werden unter Verwendung des folgenden zufälligen Objekts R generiert:
Random r = neu random ();
A. Generieren Sie Dezimalstellen des Intervalls [0,1.0)
double d1 = R.NextDouble ();
Es wird direkt unter Verwendung der NextDouble -Methode erhalten.
B. Generieren Sie Dezimalstellen des Intervalls [0,5,0)
Double D2 = R.NextDouble () * 5;
Da das von der NextDouble -Methode erzeugte Zahlenintervall [0, 1.0) ist, ist das Erweitern des Intervalls um das 5 -fache das erforderliche Intervall.
Um eine zufällige Dezimalzahl im Intervall zu erzeugen [0, d) und D ist eine positive Dezimalzahl, müssen Sie nur den Rückgabewert der NextDouble -Methode mit d multiplizieren.
C. Generieren Sie die Dezimalzahl [N1, N2] des Intervalls [1, 2.5) [1]
Doppel d3 = R.NextDouble () * 1,5 + 1;
Um eine zufällige Dezimalzahl des Intervalls zu erzeugen [1, 2.5), müssen Sie zuerst eine zufällige Anzahl des Intervalls [0, 1,5) generieren und dann dem generierten Zufallszahlenintervall 1 hinzufügen.
Um eine zufällige Zahl im Bereich des Dezimalintervalls [D1, D2) zu erzeugen, der nicht von 0 beginnt (wobei D1 nicht gleich 0 ist), müssen Sie erst zuerst eine Zufallszahl im Intervall [0, D2-D1) generieren und dann das generierte Zufallszahlenintervall zu D1 hinzufügen.
D. Jede ganze Zahl erzeugen
int n1 = r.Nextint ();
Verwenden Sie einfach die nächste Methode direkt.
e. Erzeugen Sie Ganzzahlen im Intervall [0,10)
int n2 = r.Nextint (10); n2 = math.abs (r.Nextint () % 10);
Die obigen zwei Codezeilen können Ganzzahlen im Intervall [0,10) generieren.
Die erste Implementierung wird direkt mit der NextInt (int n) -Methode in der Zufallsklasse implementiert.
In der zweiten Implementierung wird die erste Methode von NextInt () zur Generierung einer willkürlichen INT -Nummer generiert. Das durch die Zahl der Zahl 10 generierte Intervall ist (-10,10), da nach der mathematischen Spezifikation der Absolutwert des Restes geringer ist als der Divisor, und dann wird der Absolutwert des Intervalls berechnet und das resultierende Intervall beträgt [0,10).
In ähnlicher Weise können Sie den folgenden Code verwenden, um zufällige Ganzzahlen in jedem Intervall zu generieren [0, n):
int n2 = r.Nextint (n); n2 = math.abs (r.Nextint () % n);
F. Erzeugen Sie Ganzzahlen im Intervall [0,10]
int n3 = R.Nextint (11); n3 = math.abs (R.Nextint () % 11);
Im Vergleich zum Ganzzahlintervall sind das Intervall [0,10] und das [0,11) Intervall gleichwertig, sodass eine Ganzzahl des [0,11) -Intervalls erzeugt wird.
G. Erzeugen Sie Ganzzahlen im Intervall [-3,15)
int n4 = R.Nextint (18) - 3; // 【Das heißt, R.Nextint () * (N2 -N1)+N1】 N1 ist eine negative Zahl n4 = math.abs (R.Nextint () % 18) - 3;
Um zufällige ganze Zahlen zu generieren, die nicht von 0 beginnen, können Sie sich auf die obige Beschreibung des Implementierungsprinzips des Dezimalintervalls beziehen, das nicht von 0 beginnt.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.