Java - Random Long, Float, Integer e Double

Questo rapido tutorial illustrerà come generare un primo lungo utilizzando Java semplice e utilizzando la libreria Apache Commons Math.

Questo articolo fa parte della serie "Java - Back to Basic" qui su Baeldung.

1. Genera un Unbounded Long

Cominciamo con la generazione di un Long:

@Test public void givenUsingPlainJava_whenGeneratingRandomLongUnbounded_thenCorrect() { long generatedLong = new Random().nextLong(); }

2. Genera un lungo all'interno di un intervallo

2.1. Casuale lungo con Java normale

Successivamente, diamo un'occhiata alla creazione di un Long limitato casuale, ovvero un valore Long all'interno di un dato intervallo o intervallo:

@Test public void givenUsingPlainJava_whenGeneratingRandomLongBounded_thenCorrect() { long leftLimit = 1L; long rightLimit = 10L; long generatedLong = leftLimit + (long) (Math.random() * (rightLimit - leftLimit)); }

2.2. Casuale lungo con Apache Commons Math

Diamo un'occhiata alla generazione del Long casuale con un'API più pulita e Commons Math:

@Test public void givenUsingApacheCommons_whenGeneratingRandomLongBounded_thenCorrect() { long leftLimit = 10L; long rightLimit = 100L; long generatedLong = new RandomDataGenerator().nextLong(leftLimit, rightLimit); }

3. Genera un numero intero illimitato

Passiamo direttamente alla generazione di un numero intero casuale senza limiti:

@Test public void givenUsingPlainJava_whenGeneratingRandomIntegerUnbounded_thenCorrect() { int generatedInteger = new Random().nextInt(); }

Come puoi vedere, è abbastanza vicino a generare un file long.

4. Genera un numero intero all'interno di un intervallo

4.1. Numero intero casuale con Java normale

Avanti: un numero intero casuale all'interno di un determinato intervallo:

@Test public void givenUsingPlainJava_whenGeneratingRandomIntegerBounded_thenCorrect() { int leftLimit = 1; int rightLimit = 10; int generatedInteger = leftLimit + (int) (new Random().nextFloat() * (rightLimit - leftLimit)); }

4.2. Intero casuale con Commons Math

E lo stesso con Common Math:

@Test public void givenUsingApache_whenGeneratingRandomIntegerBounded_thenCorrect() { int leftLimit = 1; int rightLimit = 10; int generatedInteger = new RandomDataGenerator().nextInt(leftLimit, rightLimit); }

5. Genera un flottante illimitato

Ora, passiamo alla generazione di float casuali, prima illimitati:

@Test public void givenUsingPlainJava_whenGeneratingRandomFloatUnbouned_thenCorrect() { float generatedFloat = new Random().nextFloat(); }

6. Genera un galleggiante all'interno di un intervallo

6.1. Galleggiante casuale con Java normale

E un galleggiante casuale limitato:

@Test public void givenUsingPlainJava_whenGeneratingRandomFloatBouned_thenCorrect() { float leftLimit = 1F; float rightLimit = 10F; float generatedFloat = leftLimit + new Random().nextFloat() * (rightLimit - leftLimit); }

6.2. Float casuale con Commons Math

Ora - un float casuale limitato con Commons Math:

@Test public void givenUsingApache_whenGeneratingRandomFloatBounded_thenCorrect() { float leftLimit = 1F; float rightLimit = 10F; float randomFloat = new RandomDataGenerator().getRandomGenerator().nextFloat(); float generatedFloat = leftLimit + randomFloat * (rightLimit - leftLimit); }

7. Genera un doppio illimitato

7.1. Doppio illimitato casuale con Java normale

Infine, genereremo valori doppi casuali, innanzitutto con l'API Java Math:

@Test public void givenUsingPlainJava_whenGeneratingRandomDoubleUnbounded_thenCorrect() { double generatedDouble = Math.random(); }

7.2. Doppio casuale illimitato con Commons Math

Oltre a un valore double casuale con la libreria Apache Commons Math:

@Test public void givenUsingApache_whenGeneratingRandomDoubleUnbounded_thenCorrect() { double generatedDouble = new RandomDataGenerator().getRandomGenerator().nextDouble(); }

8. Genera un doppio all'interno di un intervallo

8.1. Doppio delimitato casuale con Java normale

In questo esempio, diamo un'occhiata a un double casuale generato all'interno di un intervallo - con Java:

@Test public void givenUsingPlainJava_whenGeneratingRandomDoubleBounded_thenCorrect() { double leftLimit = 1D; double rightLimit = 10D; double generatedDouble = leftLimit + new Random().nextDouble() * (rightLimit - leftLimit); }

8.2. Doppio delimitato casuale con Commons Math

E infine, un doppio casuale all'interno di un intervallo, utilizzando la libreria Apache Commons Math:

@Test public void givenUsingApache_whenGeneratingRandomDoubleBounded_thenCorrect() { double leftLimit = 1D; double rightLimit = 100D; double generatedDouble = new RandomDataGenerator().nextUniform(leftLimit, rightLimit); }

E il gioco è fatto: esempi rapidi e concreti di come generare valori illimitati e limitati per le primitive numeriche più comuni in Java.

9. Conclusione

Questo tutorial ha illustrato come possiamo generare numeri casuali legati o non legati, utilizzando diverse tecniche e librerie.

Come sempre, l'implementazione di tutti questi esempi e frammenti può essere trovata nel progetto GitHub. Questo è un progetto basato su Maven, quindi dovrebbe essere facile da importare ed eseguire.