Java - Random Long, Float, Integer och Double

Denna snabba handledning kommer att illustrera hur man genererar en lång först med vanlig Java och med Apache Commons Math-biblioteket.

Den här artikeln är en del av "Java - Back to Basic" -serien här på Baeldung.

1. Skapa en obegränsad lång

Låt oss börja med att skapa en Long:

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

2. Generera en lång inom ett intervall

2.1. Slumpmässig lång med vanlig Java

Nästa - låt oss titta på att skapa ett slumpmässigt begränsat långt - det vill säga ett långt värde inom ett visst intervall eller intervall:

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

2.2. Slumpmässigt långt med Apache Commons Math

Låt oss ta en titt på att generera den slumpmässiga Long med ett renare API och Commons Math:

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

3. Skapa ett obegränsat heltal

Låt oss gå vidare till att generera ett slumpmässigt heltal utan gränser:

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

Som du kan se är det ganska nära att generera en lång.

4. Generera ett heltal inom ett intervall

4.1. Slumpmässigt heltal med vanlig Java

Nästa - ett slumpmässigt heltal inom ett visst intervall:

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

4.2. Slumpmässigt heltal med allmän matematik

Och detsamma med Common Math:

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

5. Skapa en obegränsad flottör

Nu, låt oss gå över att generera slumpmässiga flottörer - först obegränsat:

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

6. Generera en flottör inom ett intervall

6.1. Slumpmässig flytning med vanlig Java

Och en begränsad slumpmässig flottör:

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

6.2. Slumpmässig flytning med Commons Math

Nu - en begränsad slumpmässig flottör med 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. Generera en obegränsad dubbel

7.1. Slumpmässig obegränsad dubbel med vanlig Java

Slutligen - vi kommer att generera slumpmässiga dubbla värden - först med Java Math API:

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

7.2. Slumpmässig obegränsad dubbel med allmän matematik

Samt ett slumpmässigt dubbelvärde med Apache Commons Math-biblioteket:

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

8. Generera en dubbel inom ett intervall

8.1. Slumpmässigt avgränsad dubbel med vanlig Java

I det här exemplet, låt oss ta en titt på en slumpmässig dubbel genererad inom ett intervall - med Java:

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

8.2. Slumpmässigt avgränsat dubbel med allmän matematik

Och slutligen - en slumpmässig dubbel inom ett intervall med hjälp av Apache Commons Math-biblioteket:

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

Och där har du det - snabba och enkla exempel på hur man genererar både obegränsade och avgränsade värden för de vanligaste numeriska primitiverna i Java.

9. Slutsats

Denna handledning illustrerade hur vi kunde generera slumpmässiga nummer antingen bundna eller obundna med hjälp av olika tekniker och bibliotek.

Som alltid finns implementeringen av alla dessa exempel och utdrag i GitHub-projektet. Detta är ett Maven-baserat projekt så det ska vara enkelt att importera och köra.