Mi a véletlenszám-generátor a Java-ban?
A véletlen számokat általában használják olyan alkalmazások készítéséhez, mint például a Dice társasjátékhoz, a Szerencsejáték Programhoz, stb. Általában a véletlen szám generálása sok időt vesz igénybe. A Java programozási nyelvben azonban ezt három módon lehet elérni. Ezekkel a Java véletlenszerű szám-generátor funkciói alább olvashatók.
Véletlenszám-generátor funkciók a Java-ban
A Java-ban a véletlen számok 3 módon állíthatók elő:
- Math.random módszer
- java.util.Random osztály
- ThreadLocalRandom osztály
1. Math.random () módszer
A Java Math osztály számos módszert kínál a számítások elvégzésére, például logaritmusok, átlagok, exponenciák stb. Az 1.0 kizárólagos. Ez a módszer használható paraméterekkel vagy anélkül. Paraméterek megadása esetén a generált véletlenszám az adott paraméter tartományán belül lesz.
1. példa
Kód:
public class RandomNumber (
double num; //Declare a variable num
//Method which generates a random number
public double randnum()
(
num=Math.random();
return num;
)
// Main Method of a program
public static void main(String() args) (
//Printing a random number
System.out.println("Random Number generated inside main method: "+Math.random());
//Create an object of the class RandomNumber
RandomNumber randomobj=new RandomNumber();
//Store the return value obtained from randnum method in a variable randomval
double randomval=randomobj.randnum();
//Printing the random number stored in variable randomval
System.out.println("Random Number generated inside randomnumber method: "+randomval);
)
)
Kimenet:
A fenti példában a Véletlenszerű számot a Math.random () módszer alkalmazásával hozza létre kétféle módon - Közvetlenül alkalmazva azt a fő módszer belsejében, és egy olyan módszer meghívására, amely az Math.random () -t tartalmazza az objektum segítségével. Amint azt a fenti magyarázatban említettük, láthatjuk, hogy 2 véletlenszámot generálunk a 0, 0 és 1, 0 tartományban.
A paraméterek tartományán belüli véletlenszerű szám generálásához az alábbiakban említjük a használt általános kifejezést:
Math.random () * ((max. Érték - min. Érték) +1) + min. Érték
2. példa
Ahol a maximális érték a tartomány felső határa, a min érték pedig a tartomány alsó határa. Például, ha véletlenszerű számot szeretne létrehozni 10 és 20 között, állítsa a maximális értéket 20-ra, a minimális értéket pedig 10-re.
Kód:
public class RandomNumParameters (
public double randomnum(double x, double y)//max value-y, min value-x
(
double z =(Math.random()*((yx)+1)+x); //Formula for random number generation within a range
return z;
)
public static void main(String() args)
(
RandomNumParameters ran=new RandomNumParameters(); //Create instance for the class RandomNumParameters
double num=ran.randomnum(3.0, 10.0); //Call the Method
System.out.println("Random number generated within the range of 3 and 10: "+num );
) )
Kimenet:
2. java.util.Random osztály
A Java.util.Random osztály különféle típusú véletlenszerű számokat generál, mint például úszó, hosszú, egész szám, kettős, logikai, stb. Arra is lehetőség van, hogy argumentumként átadjuk a számtartományt, így véletlenszerű számot generálunk ezen a tartományon belül. . Ennek az osztálynak a használatához a java.util véletlenszerű osztályát kell importálni (java.util.Random). Miután ezt az osztályt importálták, hozzon létre egy példányt, és hívja meg a példány használatával a következő hosszúkat (), nextInt () stb.
1. példa
Kód:
//Java program to generate Random numbers using Random class
package Sample;
import java.util.Random; //import Random Class
public class RandomNum (
public static void main(String() args) (
Random rand=new Random(); //Create instance of Random class
double randomnum=rand.nextDouble(); //Assign the Random Double value in randomnum variable
System.out.println("Random Double value: "+ randomnum);
)
)
Kimenet:
A fenti programban véletlenszerű dupla értéket generálunk a nextDouble () módszerrel.
3. ThreadLocalRandom osztály
A ThreadLocalRandom osztály egy véletlen osztály speciális típusa, amelyet a Java 1.7-es verziójában vezettek be. A ThreadLocalRandom.current (). NextInt () az egyik leggyakoribb módszer, amellyel véletlenszerű számokat generálnak. Általában többszálú alkalmazásokban használják.
1. példa
Kód:
//Java Program to generate random numbers using ThreadLocalRandom Class
import java.util.concurrent.ThreadLocalRandom;
public class RandomNumThread (
public static void main(String() args) (
//print a random double
System.out.println("Random Double value using ThreadLocalRandom: "+ThreadLocalRandom.current().nextDouble());
)
)
Kimenet:
Egész számok generálása
Véletlen egész számok generálhatók a ThreadLocalRandom osztály és a Random Class használatával. Mindkét esetben a NextInt () metódust kell használni ehhez:
1. példa
Kód:
//Java program to generate Random integer numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomInteger (
public static void main(String() args) (
Random rnd=new Random(); //Create instance of Random class
int randomnum1=rnd.nextInt(); //Random Integer value using Random Class
int randomnum2=rnd.nextInt(30); //Random Integer value within the range of 30
int randomnum3= ThreadLocalRandom.current().nextInt(); //Random Integer value using ThreadLocalRandom Class
System.out.println("Random Integer value using Random Class: "+ randomnum1);
System.out.println("Random Integer value within the range of 30: "+ randomnum2);
System.out.println("Random Integer value using ThreadLocalRandom Class: "+ randomnum3);
)
)
Kimenet:
A fenti példában három véletlenszerű egész számot generálunk, ahol a nextInt () módszer egyikének argumentuma van 30. Tehát a véletlenszerű szám generálása közben a 30-at állítják fel felső határként, a nullát (az alapértelmezett alsó határértéket) pedig az alsó határértéket.
Lebegőpontos számok előállítása
Az egész számok előállításához hasonlóan a lebegőpontos számok a NextFloat () módszerrel is előállíthatók. Ez a módszer használható mind a Random Class, mind a ThreadLocalRandom osztályban:
1. példa
Kód:
//Java program to generate Random Float numbers using Random and THreadLocalRandom Class
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class RandomFloat (
public static void main(String() args) (
Random rnd=new Random(); //Create instance of Random class
float randomnum1=rnd.nextFloat(); //Random Float value using Random Class
float randomnum2= ThreadLocalRandom.current().nextFloat(); //Random Float value using ThreadLocalRandom Class
System.out.println("Random float value using Random Class: "+ randomnum1);
System.out.println("Random float value using ThreadLocalRandom Class: "+ randomnum2);
)
)
Kimenet:
Következtetés
A Java számos olyan funkciót tartalmaz, amelyek felhasználhatók a programokban. Ez elősegíti a feldolgozási idő és a kódvonalak csökkentését. A véletlenszám-generálás az egyik feladat, ahol felhasználhatjuk ezen funkciók némelyikét. Ez a dokumentum ismerteti az ennek elérésére szolgáló különféle módszereket.
Ajánlott cikkek
Ez egy útmutató a véletlenszám-generátorhoz Java-ban. Itt a java funkcióit tárgyaljuk példákkal és két különféle generátorral. Megnézheti más kapcsolódó cikkeket is, ha többet szeretne megtudni -
- Véletlenszám-generátor Pythonban
- Véletlenszám-generátor C-ben
- Véletlenszám-generátor R-ben
- Rekurszió Java-ban
- Véletlenszám-generátor a Matlab-ban
- Véletlenszám-generátor C # -ben
- Tömbök a Java programozásban
- Véletlenszám-generátor a JavaScript-ben
- Véletlenszám-generátor a PHP-ben