Come generare numeri casuali in Java


Vorrei introdurre numeri casuali in Java. Prima ti darò ciò che siete venuti per: esempi pronto, poi andrò dietro le quinte di generazione di numeri casuali in Java. Vado oltre ogni metodo che genera un numero "casuale" in Java. Spiegare perché i numeri generati non sono veramente casuale, e come una distribuzione normale è correlato al numero casuale in Java.

Quindi, senza ulteriori indugi, ecco un esempio che copre tutti i metodi generare un numero casuale in Java standard (al momento della stesura e JDK JRE 6 sono nella loro prima versione 22 di aggiornamento) di Windows (Si noti che viene utilizzato un nuovo java.util.Random dichiarazione quando si chiama Math.random (), in modo che tutti i miei esempi usare pacchetto java.util manuale. casuale).




numeri casuali Java codice di esempio

Pacchetto MathRandom_Java; java.util.Random importazione; public class Java_Math_Random_All { public static void main (String ... stringhe) { // Crea una nuova istanza o un oggetto di classe Random Util_Random casuale = new Random (); // Genera un numero pseudo-casuale compreso tra 0.0 e 1.0 // (Nota: il numero varierà da 0.0 a 1.0, ma non 1.0) Doppia util_Random_Double util_Random.nextDouble = (); // Restituisce il pseudorandom successiva, gaussiana ("normalmente") distribuito // Valore mezzo doppia e una deviazione standard 0,0 1,0 Doppia util_Random_Gaussian util_Random.nextGaussian = (); // Genera un numero compreso tra 1.40129846432481707e-45 // Per 3.40282346638528860e + 38 (positivo o negativo) util_Random_Float util_Random.nextFloat float = (); // Genera un numero compreso tra -9.223.372.036.854.775.808 // A +9.223.372.036.854.775.807 util_Random_Long lungo util_Random.nextLong = (); // Genera un numero compreso tra -2147483648-2147483647 util_Random_Integer util_Random.nextInt int = (); // Genera un intero da un range specificato (se la scheda d ' // Parametro N come numeri da 0 a n-1) util_Random_Integer_from_n util_Random.nextInt = int (32); // Genera pseudo è vera o falsa boolean util_Random_Bool util_Random.nextBoolean = (); // Creare e inizializzare un array di 5 byte byte [] byte = new byte [5]; // Riempire la matrice con cinque byte generati a caso // Nota: byte è un valore compreso tra -128 a 127 util_Random.nextBytes (byte); // Creare un oggetto e invita java.util.Random // Il metodo nextDouble () Doppia math_Random = Math.random (); // Visualizza tutti i risultati dei metodi di cui sopra System.out.println ("Math.random () ->" + math_Random); System.out.println ("nextDouble () ->" + util_Random_Double); System.out.println ("nextGaussian () ->" + util_Random_Gaussian); System.out.println ("nextFloat () ->" + util_Random_Float); System.out.println ("nextLong () ->" + util_Random_Long); System.out.println ("nextInt () ->" + util_Random_Integer); System.out.println ("nextInt (n) ->" + util_Random_Integer_from_n); System.out.println ("nextBoolean () ->" + util_Random_Bool); System.out.println ("nextBytes (byte) ->"); for (int i = 0; i I risultati dei campioni

Math.random () -> 008014059073862545
NextDouble () -> 4017283520137178
nextGaussian () -> -0,5345105808614735
nextFloat () -> 0,6654831
nextLong () -> 982543587599054257
nextInt () -> -502 464 678
nextInt (n) -> 3
nextBoolean () -> true
nextBytes (byte) ->
Byte 1: 62
Byte 2: -83
Byte 3: -93
Byte 4: 114
Byte 5: -109

Java Books

nextInt

Primo avviso che a seconda delle esigenze, qualunque esse possono essere alla ricerca sta generando un semplice intero casuale nella gamma di scelta.

Per fare questo, vi consiglio di utilizzare nextInt (int n) metodo. Solo ricordare che se si desidera generare numeri da 0 a n passare un numero che è uguale a n + 1.

Per esempio se voglio generare numeri nel range di 0-32 spenderebbe 33 in questo modo: nextInt (33)


E se volevo limitare la mia fascia bassa, vorrei aggiungere un numero a quello che nextInt generato da (int n), e sottraendo lo stesso numero di n. La esempio nextInt (33-10) 10 genera numeri nella gamma di 10 a 32.

Displays

Codice nextInt

Pacchetto MathRandom_Java; java.util.Random importazione; public class Java_Math_Random_Int { public static void main (String ... stringhe) { // Crea una nuova istanza o un oggetto di classe Random Util_Random casuale = new Random (); // Genera un intero da un range specificato (se la scheda d ' // Parametro N come numeri da 0 a n-1) int = pseudorandom_Integer util_Random.nextInt (32 + 1); System.out.println ("nextInt (n) ->" + pseudorandom_Integer); // Genera un numero intero 10-32 compreso esclusiva. pseudorandom_Integer = util_Random.nextInt (33-10) + 10; System.out.println ("nextInt (n-10) + 10 ->" + pseudorandom_Integer); } }

I risultati dei campioni

nextInt (n) -> 27
nextInt (n-10) + 10 -> 16

Abbinamento

Java non è casuale

Generazione di un numero casuale in un computer non è casuale. C'è un algoritmo che prende il numero di millisecondi poiché UNIX epoca. Poiché il numero di millisecondi sempre modifiche, un numero generato da metodi casuali molti Java sembra essere casuale.

Se si dovesse modificare manualmente il numero millisecondi (un valore seed) per istanza di classe casuale o un oggetto, si potrebbe vedere che ogni volta che viene generato un valore di "random", si ottiene stesso risultato! Eseguire questo codice più volte per capire cosa intendo:

Pacchetto MathRandom_Java; java.util.Random importazione; public class Java_Math_Random_Seed { public static void main (String ... stringhe) { // Crea una nuova istanza o un oggetto di classe Random Util_Random casuale = new Random (); // Se si imposta manualmente il seme per l'oggetto a caso, // Il valore generato sarà lo stesso in ogni gara. util_Random.setSeed (555); // Genera un numero casuale pseudo tra 0,0 e 1,0 // (Note Number varierà da 0.0 a 1.0, // Ma mai 1.0) Doppia util_Random_Double util_Random.nextDouble = (); System.out.println ("nextDouble () ->" + util_Random_Double); } }

campione di uscita - la stessa su tutti i computer

NextDouble () -> 0,6816084544091354

Uniform vs distribuzioni normali metodi casuali in Java

Un altro punto da considerare è che quasi tutti i metodi in Java utilizzando casuale Metodo per la distribuzione uniforme di valori. Quale in termini semplici significa che la probabilità di selezionare un numero casuale di pseudo tutti i possibili numeri casuali che possono produrre un computer essere lo stesso.

L'eccezione a questa regola è il metodo chiamato nextGausian () che genera un numero pseudo-casuale secondo normale distribuzione. Traduzione lingue più facili: i valori nextGausian generato () sono sbilanciata verso la più probabile, e Probabilmente è 0. Ad esempio, 0.5 è molto più probabile sembrano essere generato da nextGaussian () che dire di 0,0005.

distribuzione Blurb normale

Una curva a campana, che è anche chiamata una curva normale è formato. Quasi tutto in natura (compresi i comportamenti umani, come ad esempio guardare TV) viene eseguita secondo questa curva standard (se misurato e graficamente).

La curva normale solo potrebbe avere un sacco di volumi di scrittura e non saranno coperti in questo articolo, in modo sufficiente dire se volevo fare una domanda che potrebbe simulare un ambiente naturale comportamento utilizzare il metodo nextGaussian ().

Last Words

Per riassumere il tutto lì, tre cose fondamentali che si dovrebbero prendere in considerazione quando si generano valori pseudo-casuali:

  1. La maggior parte dei metodi utilizzano una distribuzione uniforme, ma non è un metodo che utilizza la normale o gaussiana chiamata distribuzione nextGaussian ().
  2. Se si desidera semplicemente per generare una serie di pseudo numeri casuali interi positivi zero n quindi usare nextInt (n + 1).
  3. In alternativa, se si desidera generare una serie di pseudo numeri casuali interi positivi un m n, quindi usare nextInt (n - m) + m, m è inferiore a n.

(0)
(0)

Commenti - 0

Non ci sono commenti

Aggiungi un commento

smile smile smile smile smile smile smile smile
smile smile smile smile smile smile smile smile
smile smile smile smile smile smile smile smile
smile smile smile smile
Caratteri rimanenti: 3000
captcha