streamalism.org

Ez a gyors bemutató bemutatja, hogyan lehet előbb hosszúakat létrehozni egyszerű Java használatával és az Apache Commons Math könyvtár használatával.

Ez a cikk a „Java - Vissza az alapokhoz” sorozat része, itt, Baeldungon.

1. Készítsen korlátlan hosszút

Kezdjük egy Long előállításával:

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

2. Generáljon hosszút egy tartományon belül

2.1. Véletlen hosszú, sima Java-val

Ezután - nézzük meg egy véletlenszerűen kötött hosszú - azaz egy hosszú érték létrehozását egy adott tartományon vagy intervallumon belül:

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

2.2. Véletlen hosszú az Apache Commons Math-tal

Vessünk egy pillantást a véletlenszerű Long előállítására egy tisztább API-val és a Commons Math-tal:

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

3. Készítsen korlátlan egész számot

Térjünk át egy véletlen egész szám generálására korlátok nélkül:

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

Mint láthatja, elég közel áll ahhoz, hogy hosszút generáljon.

4. Generáljon egész számot egy tartományon belül

4.1. Véletlen egész szám sima Java-val

Következő - egy véletlenszerű egész szám egy adott tartományon belül:

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

4.2. Véletlenszerű egész szám a Commons Math-tal

És ugyanez a Common Math esetében:

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

5. Készítsen korlátlan úszót

Most nézzük át véletlenszerű úszók létrehozását - először korlátlanul:

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

6. Generáljon úsztatást egy tartományon belül

6.1. Véletlenszerű lebegés egyszerű Java-val

És egy korlátozott véletlenszerű úszó:

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

6.2. Random Float With Commons Math

Most - egy korlátozott véletlenszerű úszó a Commons Math-szal:

@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. Hozzon létre egy korlátlan kettőt

7.1. Véletlen, korlátlan kettős sima Java-val

Végül - véletlenszerű dupla értékeket állítunk elő - először a Java Math API-val:

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

7.2. Véletlen, korlátlan kettős, Commons Math

Valamint egy véletlenszerű dupla érték az Apache Commons Math könyvtárral:

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

8. Generáljon duplát egy tartományon belül

8.1. Véletlenszerűen kötött kettős sima Java-val

Ebben a példában vessünk egy pillantást egy intervallumon belül generált véletlenszerű duplára - Java-val:

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

8.2. Random Bounded Double with Commons Math

És végül - véletlenszerű dupla intervallumon belül, az Apache Commons Math könyvtár segítségével:

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

És itt van - gyors és lényegre törő példák arra, hogyan lehet korlátlan és korlátozott értékeket létrehozni a Java leggyakoribb numerikus primitívjeihez.

9. Következtetés

Ez az oktatóanyag bemutatta, hogyan állíthatunk elő véletlenszerű számokat kötött vagy kötetlen formában, különböző technikák és könyvtárak segítségével.

Mint mindig, ezeknek a példáknak és kivonatoknak a megvalósítása megtalálható a GitHub projektben. Ez egy Maven-alapú projekt, így könnyen importálhatónak és futtathatónak kell lennie.