Numerele aleatorii generate de computer sunt împărțite în două categorii: numere aleatorii adevărate și numere pseudo-aleatorii.

Numerele aleatoare adevărate sunt generate pe baza factorilor externi. De exemplu, generarea aleatoriei folosind zgomotele din jur.

Dar generarea unui astfel de număr aleatoriu adevărat este o sarcină care consumă mult timp. Prin urmare, putem utiliza numere pseudo-aleatorii care sunt generate folosind un algoritm și o valoare seed.

Aceste numere pseudo-aleatorii sunt suficiente pentru majoritatea scopurilor. De exemplu, le puteți folosi în criptografie, în construirea de jocuri precum zaruri sau cărți și în generarea de numere OTP (parolă unică).

În acest articol, vom învăța cum să generăm numere pseudo-aleatorii folosind Math.random() în Java.

1. Utilizați Math.random () pentru a genera numerele întregi

Math.random() returnează un număr pseudo-aleatoriu de tip dublu, mai mare sau egal cu zero și mai mic decât unul.

Să încercăm cu un cod:

    public static void main(String[] args) {
        double randomNumber = Math.random();
        System.out.println(randomNumber);
    }
    // output #1 = 0.5600740702032417
    // output #2 = 0.04906751303932033

randomNumber ne va da un număr aleatoriu diferit pentru fiecare execuție.

Să presupunem că vrem să generăm numere aleatorii într-un interval specificat, de exemplu, de la zero la patru.

    // generate random numbers between 0 to 4
    public static void main(String[] args) {
        // Math.random() generates random number from 0.0 to 0.999
        // Hence, Math.random()*5 will be from 0.0 to 4.999
        double doubleRandomNumber = Math.random() * 5;
        System.out.println("doubleRandomNumber = " + doubleRandomNumber);
        // cast the double to whole number
        int randomNumber = (int)doubleRandomNumber;
        System.out.println("randomNumber = " + randomNumber);
    }
    /* Output #1
    doubleRandomNumber = 2.431392914284627
    randomNumber = 2
    */

Când lansăm o valoare dublă la int, valoarea int păstrează doar o parte din număr întreg.

De exemplu, în codul de mai sus, doubleRandomNumber este 2.431392914284627 . doubleRandomNumberpartea cu numărul întreg este 2 iar partea fracționată (numerele după punctul zecimal) este 431392914284627 . Asa de, randomNumber va deține doar partea cu numărul întreg 2.

Puteți citi mai multe despre Math.random() metoda în Documentație Java.

Folosind Math.random() nu este singura modalitate de a genera numere aleatorii în Java. Apoi, vom analiza modul în care putem genera numere aleatorii folosind clasa Random.

2. Utilizați clasa aleatorie pentru a genera numere întregi

În clasa Random, avem multe metode de instanță care furnizează numere aleatorii. În această secțiune, vom lua în considerare două metode de instanță, nextInt(int bound), și nextDouble().

Cum se folosește metoda nextInt (int bound)

nextInt(int bound) returnează un număr pseudo-aleatoriu de tip int, mai mare sau egal cu zero și mai mic decât valoarea legată.

bound parametrul specifică intervalul. De exemplu, dacă specificăm legătura ca 4, nextInt(4) va returna o valoare de tip int, mai mare sau egală cu zero și mai mică de patru. 0,1,2,3 sunt rezultatele posibile ale nextInt(4) .

Deoarece aceasta este o metodă de instanță, ar trebui să creăm un obiect aleatoriu pentru a accesa această metodă. Hai sa incercam.

    public static void main(String[] args) {
        // create Random object
        Random random = new Random();
        // generate random number from 0 to 3
        int number = random.nextInt(4);
        System.out.println(number);
    }

Cum se folosește metoda nextDouble ()

Similar cu Math.random() , nextDouble() returnează un număr pseudo-aleatoriu de tip dublu, mai mare sau egal cu zero și mai mic decât unul.

    public static void main(String[] args) {
        // create Random object
        Random random = new Random();
        // generates random number from 0.0 and less than 1.0
        double number = random.nextDouble();
        System.out.println(number);
    }

Pentru mai multe informații, puteți citi clasa aleatorie Documentație Java.

Deci, care ar trebui să utilizați metoda numărului aleator?

Math.random() folosește clasa aleatorie. Dacă dorim doar numere pseudo-aleatorii de tip dublu în aplicația noastră, atunci putem folosi Math.random() .

În caz contrar, putem folosi clasa aleatorie, deoarece oferă diferite metode pentru a genera numere pseudo-aleatorii în diferite tipuri, cum ar fi nextInt(), nextLong(), nextFloat() și nextDouble().

Mulțumesc că ai citit.

Imagine foto de Brett Jordan pe Unsplash

Vă puteți conecta cu mine pe Mediu.

Codificare fericită!