In Giava programmazione, spesso lo richiedevamo generare numeri casuali mentre sviluppiamo applicazioni. Molte applicazioni hanno la funzionalità di generare numeri in modo casuale , ad esempio per verificare che l'utente utilizzi molte applicazioni OTP . Il miglior esempio di numeri casuali sono i dadi. Perché quando lo lanciamo, otteniamo un numero casuale compreso tra 1 e 6.
In questa sezione impareremo cos'è a numero casuale E come generare numeri casuali in Giava .
Numero casuale
I numeri casuali sono i numeri che utilizzano un ampio insieme di numeri e selezionano un numero utilizzando l'algoritmo matematico. Soddisfa le seguenti due condizioni:
- I valori generati sono distribuiti uniformemente su un intervallo definito.
- È impossibile indovinare il valore futuro sulla base dei valori attuali e passati.
Generazione di numeri casuali in Java
In Java, esistono tre modi per generare numeri casuali utilizzando il metodo e le classi.
- Usando il casuale() Metodo
- Usando il casuale Classe
- Usando il ThreadLocalRandom Classe
- Usando il int() Metodo (in Java 8)
Utilizzando il metodo Math.random()
Il Giava Matematica La classe ha molti metodi per diverse operazioni matematiche. Uno di questi è il casuale() metodo. È un statico metodo della classe Math. Possiamo invocarlo direttamente. Genera solo Doppio digitare un numero casuale maggiore o uguale a 0,0 E meno di 1,0 . Prima di utilizzare il metodo random(), dobbiamo importare il filejava.lang.Mathclasse.
Sintassi:
public static double random()
Non accetta alcun parametro. Restituisce un doppio pseudocasuale maggiore o uguale a 0,0 e inferiore a 1,0.
Creiamo un programma che generi numeri casuali utilizzando il metodo random().
NumeroCasualeEsempio1.java
import java.lang.Math; public class RandomNumberExample1 { public static void main(String args[]) { // Generating random numbers System.out.println('1st Random Number: ' + Math.random()); System.out.println('2nd Random Number: ' + Math.random()); System.out.println('3rd Random Number: ' + Math.random()); System.out.println('4th Random Number: ' + Math.random()); } } Produzione:
1st Random Number: 0.17434160924512265 2nd Random Number: 0.4297410090709448 3rd Random Number: 0.4828656381344487 4th Random Number: 0.13267917059488898
Ricordare: Ogni volta otteniamo un output diverso quando eseguiamo il programma. L'output potrebbe differire dall'output mostrato sopra.
Possiamo anche usare la seguente formula se vogliamo generare un numero casuale compreso in un intervallo specificato.
Math.random() * (max - min + 1) + min
Nella formula precedente, il valore minimo è inclusivo mentre il valore massimo è esclusivo.
funzioni di arduino
Creiamo un programma che generi numeri casuali compresi tra 200 e 400.
NumeroCasualeEsempio2.java
public class RandomNumberExample2 { public static void main( String args[] ) { int min = 200; int max = 400; //Generate random double value from 200 to 400 System.out.println('Random value of type double between '+min+' to '+max+ ':'); double a = Math.random()*(max-min+1)+min; System.out.println(a); //Generate random int value from 200 to 400 System.out.println('Random value of type int between '+min+' to '+max+ ':'); int b = (int)(Math.random()*(max-min+1)+min); System.out.println(b); } } Uscita 1:
Random value of type double between 200 to 400: 233.88329802655377 Random value of type int between 200 to 400: 329
Uscita 2:
Random value of type double between 200 to 400: 254.8419979875385 Random value of type int between 200 to 400: 284
Utilizzando la classe casuale
Un altro modo per generare un numero casuale è utilizzare il comando Giava casuale classe deljava.utilpacchetto. Genera un flusso di numeri pseudocasuali. Possiamo generare un numero casuale di qualsiasi tipo di dati, come intero, float, double, booleano, long. Se intendi utilizzare questa classe per generare numeri casuali, segui i passaggi indicati di seguito:
- Innanzitutto, importa la classejava.lang.Random.
- Creare un oggetto della classe Casuale.
- Richiamare uno dei seguenti metodi:
Tutti i metodi di cui sopra restituiscono il successivo valore pseudocasuale, distribuito in modo omogeneo (metodo corrispondente) dalla sequenza di questo generatore di numeri casuali. IL successivoDoppio() E successivoFloat() Il metodo genera un valore casuale compreso tra 0,0 e 1,0.
IL nextInt(int limite) Il metodo accetta un limite di parametro (superiore) che deve essere positivo. Genera un numero casuale compreso tra 0 e bound-1.
Creiamo un programma che generi numeri casuali utilizzando la classe Random.
NumeroCasualeEsempio3.java
import java.util.Random; public class RandomNumberExample3 { public static void main(String args[]) { // creating an object of Random class Random random = new Random(); // Generates random integers 0 to 49 int x = random.nextInt(50); // Generates random integers 0 to 999 int y = random.nextInt(1000); // Prints random integer values System.out.println('Randomly Generated Integers Values'); System.out.println(x); System.out.println(y); // Generates Random doubles values double a = random.nextDouble(); double b = random.nextDouble(); // Prints random double values System.out.println('Randomly Generated Double Values'); System.out.println(a); System.out.println(b); // Generates Random float values float f=random.nextFloat(); float i=random.nextFloat(); // Prints random float values System.out.println('Randomly Generated Float Values'); System.out.println(f); System.out.println(i); // Generates Random Long values long p = random.nextLong(); long q = random.nextLong(); // Prints random long values System.out.println('Randomly Generated Long Values'); System.out.println(p); System.out.println(q); // Generates Random boolean values boolean m=random.nextBoolean(); boolean n=random.nextBoolean(); // Prints random boolean values System.out.println('Randomly Generated Boolean Values'); System.out.println(m); System.out.println(n); } } Produzione:
Randomly Generated Integers Values 23 767 Randomly Generated Double Values 0.37823814494212016 0.998058172671956 Randomly Generated Float Values 0.87804186 0.93880254 Randomly Generated Long Values -4974823544291679198 3650240138416076693 Randomly Generated Boolean Values false true
Utilizzando la classe ThreadLocalRandom
IL ThreadLocalRandom la classe è definita injava.util.concurrentpacchetto. Viene inizializzato con un seed generato internamente, lo stesso del generatore casuale della classe Math. Non può essere modificato. Possiamo utilizzare questa classe nel modo seguente:
tipi di dati SQL
ThreadLocalRandom.current().nextX(...)
Dove X è Int, Long, ecc.
Nota: è impossibile condividere accidentalmente un ThreadLocalRandom con più thread.
Possiamo generare un numero casuale di qualsiasi tipo di dati, come intero, float, double, booleano, long. Se intendi utilizzare questa classe per generare numeri casuali, segui i passaggi indicati di seguito:
- Innanzitutto, importa la classe utilizzandojava.util.concurrent.ThreadLocalRandom.
- Richiama il metodo corrispondente per il quale desideri generare numeri in modo casuale.
Tutti i metodi precedenti sovrascrivono il metodo corrispondente della classe Random e restituiscono il valore corrispondente.
I metodi precedenti analizzano un parametro limite (superiore) deve essere positivo . Restituisce il valore generato casualmente corrispondente tra 0 (incluso) e il limite specificato (esclusivo). Lancia IllegalArgumentExcetion se il limite è negativo.
I metodi precedenti analizzano due parametri origine E limite . L'origine specifica il valore minimo restituito e il limite specifica il limite superiore . Restituisce il valore generato casualmente corrispondente tra l'origine specificata (inclusa) e il limite (esclusivo). Inoltre, lancia IllegalArgumentExcetion se l'origine è maggiore o uguale al limite.
Creiamo un programma che generi numeri casuali utilizzando il file Classe ThreadLocalRandom .
NumeroCasualeEsempio4.java
import java.util.concurrent.ThreadLocalRandom; public class RandomNumberExample4 { public static void main(String args[]) { // Generate random integers between 0 to 999 int a = ThreadLocalRandom.current().nextInt(); int b = ThreadLocalRandom.current().nextInt(); // Print random integer values System.out.println('Randomly Generated Integer Values:'); System.out.println(a); System.out.println(b); // Generate Random double values double c = ThreadLocalRandom.current().nextDouble(); double d = ThreadLocalRandom.current().nextDouble(); // Print random doubles System.out.println('Randomly Generated Double Values:'); System.out.println(c); System.out.println(d); // Generate random boolean values boolean e = ThreadLocalRandom.current().nextBoolean(); boolean f = ThreadLocalRandom.current().nextBoolean(); // Print random Booleans System.out.println('Randomly Generated Boolean Values:'); System.out.println(e); System.out.println(f); } } Uscita 1:
Randomly Generated Integer Values: 348534891 -1887936727 Randomly Generated Double Values: 0.15644440033119833 0.5242730752133399 Randomly Generated Boolean Values: true true
Uscita 2:
ankita dave
Output 2: Randomly Generated Integer Values: 402755574 295398333 Randomly Generated Double Values: 0.4856461791062565 0.5148677091077654 Randomly Generated Boolean Values: false true
Allo stesso modo, possiamo usare altri metodi di ThreadLocalRandomclass .
Generazione di numeri casuali in Java 8
In Java 8 è stato aggiunto un nuovo metodo ints() al file Classe casuale . Dobbiamo importare il filejava.util.Randomprima di utilizzare il metodo.
int():
I valori int pseudocasuali generati equivalgono alla chiamata al metodo nextInt(). Restituisce un flusso illimitato di valori interi pseudocasuali.
ints(dimensione flusso lungo):
Il metodo analizza un parametro streamSize di tipo lungo. Specifica il numero di valori da generare. I valori int pseudocasuali generati equivalgono alla chiamata al metodo nextInt(). Restituisce inoltre un flusso di valori int generati casualmente. Lancia IllegalArgumentException se la dimensione del flusso è inferiore a zero.
ints(long streamSize, int randomNumberOrigin, int randomNumberBound):
parametri:
Restituisce un flusso di valori int pseudocasuali con l'origine e il limite specificati. Lancia IllegalArgumentException Se:
- stramSize<0< li>
- origine > = legato
ints(int randomNumberOrigin, int randomNumberBound):
parametri:
Restituisce un flusso illimitato di valori int pseudocasuali con l'origine e il limite specificati. Lancia IllegalArgumentException se l'origine è maggiore o uguale al limite.
Allo stesso modo, possiamo anche generare il flusso di tipi long e double utilizzando il file anela() E raddoppia() metodo, rispettivamente.
Creiamo un programma che generi un flusso di numeri interi utilizzando il file int() metodo della classe Random.
NumeroCasualeEsempio5.java
import java.util.Random; public class RandomNumberExample5 { public static void main(String[] args) { randomInts(5); randomInts(9, 50, 90); //getStreamOfRandomInts(30, 50); } //method that generates a stream of integers having size 5 public static void randomInts(int num) { Random random = new Random(); random.ints(num).forEach(System.out::println); } //method that generates a stream of 9 integers between 50 to 90 public static void randomInts(int num, int origin, int bound) { Random random1 = new Random(); random1.ints(num, origin, bound).forEach(System.out::println); } } Uscita 1:
727900357 -1073118456 306279822 370327182 1366265119 65 75 75 88 76 75 56 86 85
Uscita 2:
-1338107947 -1698771421 594232770 -1224937976 -1625069815 56 69 67 87 64 52 72 75 76