Java >> Java tutorial >  >> Java

Sådan bruges metoden Math.random() i Java

Java

Math.random() metoden er en af ​​Javas mest brugte metoder til at generere et tilfældigt numerisk tal. Java.lang-klassen er en indbygget klasse i Java.Math med flere matematiske procedurer, hvoraf den ene er Math.random(). Da Math.random()-metoden er en statisk metode, kan den påkaldes/kaldes uden først at konstruere en matematisk klasseinstans – java.lang.Math-klassen tilbyder flere metoder til at udføre grundlæggende numeriske operationer såsom eksponential, logaritme, kvadrat. rod og trigonometriske funktioner.

Math.random() metode i Java

Java.lang.Math.random() returnerer et positivt fortegn dobbelt resultat højere end eller lig med 0,0 men mindre end 1,0. De returnerede værdier plukkes pseudotilfældigt fra dette område med en (nogenlunde) ensartet fordeling. Når denne metode aktiveres for første gang, opretter den en enkelt ny pseudorandom-nummergenerator, ligesom den nye java.util.Random.

Sande tilfældige tal og pseudo-tilfældige tal er to typer computergenererede tilfældige tal. Ydre påvirkninger bruges til at generere virkelig tilfældige tal. For eksempel kan du bruge støj i omgivelserne til at generere randomisering.

Det tager dog tid at generere sådan et virkelig tilfældigt tal. Som et resultat kan vi bruge pseudo-tilfældige tal genereret ved hjælp af en frøværdi og en algoritme. For det meste er disse pseudo-tilfældige tal tilstrækkelige. De kan bruges i kryptografi, fremstilling af spil som terninger eller kort og generering af OTP-numre (engangskodeord).

Denne nye pseudorandom-nummergenerator bruges til alle opkald til denne metode og ingen andre steder. Denne teknik er passende synkroniseret for at tillade mange tråde at bruge den korrekt. At have hver tråds pseudotilfældige talgenerator kan afhjælpe konflikter, hvis flere tråde skal generere pseudotilfældige tal i et højt tempo.

Erklæring

Erklæringen for java.lang.Math.random() er som følger.

public static double random()

Værdien af ​​returneringen

Denne metode returnerer en pseudo-tilfældig fordobling, der er mindre end 1,0 og højere end eller lig med 0,0. Denne artikel vil give dig en omfattende forklaring af følgende principper knyttet til Math.random()-metoden:

Hvad er Math.random(), og hvordan virker det?

Det er en indbygget metode i java.lang-pakken. Det er en matematikklasse, der bruges til at generere en dobbelt datatype tilfældig værdi. Det resulterende tal vil være mindre end 1,0 og større end eller lig med 0,0.

Syntaks for begyndere

Følgende uddrag demonstrerer Math.random()-metodens grundlæggende syntaks:

public static double random()  {
}

Hvad returneres af Math.random()-metoden?

Følgende udtryk vil hjælpe dig med at forstå dette koncept bedre:

5.0 <= Math.random() < 7.5

Du kan se, at 5.0 er inkluderet i uddraget ovenfor. Det er 7,5 dog ikke. Det betyder, at Math.random()-metoden producerer en værdi fra 5,0 til 7,499999999.

Hvordan kan jeg bruge Math.random() til at erhverve en bestemt række af værdier?

Lad os sige, at vi ønsker at generere et tilfældigt tal mellem 0 og 10. Er det muligt? Ja! Math.random()-metoden i Java kan bruges til at få et bestemt område af værdier, og alt vi skal gøre er at gange den returnerede værdi af Math.random()-metoden med det ønskede område. Dette koncept er bedre forstået, hvis du bruger udtrykket nedenfor:

int randValue = (int) (Math.random() * 10);

Ovenstående kode vil generere en række værdier mellem 0 og 10 tilfældigt (10 ikke inkluderet). For også at inkludere ti, skal området angives som (n+1), dvs. 11:

int randValue = (int) (Math.random() * 11);

Uddraget ovenfor vil nu skabe tilfældige tal mellem 0 og 10.

Sådan bruger du Math.random() i Java

Lad os se på eksemplerne nedenfor for at se, hvordan Java Math.random()-metoden fungerer. Vi bruger metoden Math.random() til at producere to tilfældige værdier i dette eksempel:

public class CodeRandomMethod
{  
    public static void main(String[] args)  
    {  
        double numOne = Math.random();  
        double numTwo = Math.random();  
        System.out.println("The First Value is: " + numOne);
        System.out.println("The Second Value is: "+numTwo);
    }
}

Fordi Math.random() giver en tilfældig numerisk værdi, vil vi få et andet tal hver gang vi kører denne kode. Overvej for eksempel et andet scenarie, hvor du skal generere en tilfældig værdi inden for et bestemt område. Vi genererer en heltalsværdi mellem 0 og 10 (inklusive) i eksemplet nedenfor:

public class CodeRandomMethod {
    public static void main(String[] args) {
        int numOne = (int) (Math.random() * 11);
        System.out.println("The first value is: " + numOne);
    }
}

Vi vil få et tydeligt tilfældigt tal mellem det angivne område, hver gang vi kører dette program.

Vi kan se fra følgende kodeeksempel, at Math.random()-metoden genererer en tilfældig heltalværdi inden for det ønskede interval, hvilket indikerer, at vores applikation er passende. Vi har set, at vi kan angive en række værdier i eksemplerne ovenfor, men begyndelsesværdien er altid nul.

Vi kan dog også angive det indledende interval/værdi, i hvilket tilfælde Math.random() metoden vil generere et tilfældigt tal mellem (startværdi + (slutværdi-1)). Følgende kodestykke kan hjælpe dig med at forstå dette koncept:

public class CodeRandomMethod {

    public static void main(String[] args) {

        int numOne = 5 + (int) (Math.random() * 11);
        System.out.println(" The first value is: " + numOne);

    }

}

Startværdien er "5", og den endelige er "11" i uddraget ovenfor. Math.random()-metoden vil nu skabe et tal mellem 5 og 15 (5 + (11-1)). Outputtet validerer Math.random()-metodens funktionalitet.

package com.codeunderscored;

import java.lang.*;

public class CodeMath {

   public static void main(String[] args) {

      //two double numbers at random
      double xVal = Math.random();
      double yVal = Math.random();
   
      // print the numbers and print the higher one
      System.out.println("The first random number is:" + xVal);
      System.out.println("The second random number is:" + yVal);
      System.out.println("The highest number is:" + Math.max(xVal, yVal));
   }
}

Brug af klassen Random til at generere heltal

Der er adskillige instansmetoder i klassen Random, der genererer tilfældige heltal. Vi vil se på to instansmetoder i dette afsnit:nextInt(int bundet) og nextDouble ().

Hvad er nextInt(int bound)-metoden, og hvordan bruger jeg den?

nextInt(int bundet) returnerer et pseudo-tilfældigt heltal af int-typen, der er mindre end den bundne værdi og større end eller lig med nul. Det bundne argument angiver området. Hvis vi f.eks. sætter grænsen til 7, vil nextInt(7) returnere en int-typeværdi højere end eller lig med nul, men mindre end fire. De potentielle output af nextInt(7) er 0,1,2,3,4,5,6,7. Vi bør bygge et tilfældigt objekt for at få adgang til denne metode, fordi det er en instansmetode. Lad os prøve det.

public static void main(String[] args) {

        // creation of a random object
        Random randObject = new Random();

        // it generates random numbers from 0 to 6
        int numVal = randObject.nextInt(7);
        System.out.println(numVal);
    }

Hvad er nextDouble()-metoden, og hvordan bruger jeg den?

NextDouble()-funktionen, ligesom Math.random(), returnerer et dobbelttype pseudo-tilfældigt heltal, der er større end eller lig med nul og mindre end én.

public static void main(String[] args) {

  // creation of a Random object
  Random randObject = new Random();

  // creates a random number between 0.0 and 1.0.
  double numVal = randObject.nextDouble();
  System.out.println(numVal);
}

Eksempel:Tilfældige tal inden for et interval

At finde tilfældige tal inden for et område er et populært eksempel. Lad os se på et eksempel, hvor vi tilfældigt producerer et tal mellem 1 og 10.

public class CodeMath {
    public static void main(String[] args) {
        evaluateRandom();
    }

    private static void evaluateRandom() {
        // Generation of  random numbers from 10 to 20 (inclusive) 10 times
        for (int i=10; i<20; i++) {
            System.out.println(
                    (int)randomValueWithinRange(10,20)
            );
        }

    }
    private static double randomValueWithinRange(int smallest, int highest) {
        assert smallest < highest;

        int rangeVals = (highest - smallest) + 1;
        return ((Math.random() * rangeVals) + smallest);
    }
}

Eksempel:Math.random() i Java

class CodeUnderscoredMain {

  public static void main(String[] args) {

    // Math.random()

    // This represents the first random value
    System.out.println(Math.random());  

    // This represents the second random value
    System.out.println(Math.random());  /


    // This represents the third random value
    System.out.println(Math.random());  

  }
}

Vi kan se, at metoden random() giver tre forskellige resultater i eksemplet ovenfor.

Eksempel 2:Fremstil et tilfældigt tal mellem halvtreds og femoghalvtreds

class CodeRandomNumber {

  public static void main(String[] args) {

    int upperBoundValue = 55;
    int lowerBoundValue = 50;

    // upperBound 55 will also be included
    int rangeValue = (upperBoundValue - lowerBoundValue) + 1;

    System.out.println("Random Number values between 50 and 55:");

    for (int i = 0; i < 5; i ++) {

      // generation of a random number
      // (int) conversion of double value to int
      // Math.random() is responsible for generation of values between 50.0 and 55.0
      int random = (int)(Math.random() * rangeValue) + lowerBoundValue;

      System.out.print(random + ", ");
    }

  }
}

Eksempel:Sådan kommer du til elementer i et tilfældigt array

class CodeRandomMain {
  public static void main(String[] args) {

    // create an array
    int[] arrayVals = {22, 42, 64, 14, 83, 37, 58, 11};

    int lowerBoundValue = 0;
    int upperBoundValue = arrayVals.length;

    // arrayVals.length will excluded
    int range = upperBoundValue - lowerBoundValue;

    System.out.println("List of Random Array Elements:");


    // 5 random array elements
    for (int i = 0; i <= 5; i ++) {

      // get random array index
      int random = (int)(Math.random() * range) + lowerBoundValue;

      System.out.print(arrayVals[random] + ", ");
    }

  }
}

Så hvilken metode til at generere tilfældige tal skal du bruge?

Den tilfældige klasse bruges af Math.random(). Vi kan bruge Math.random(), hvis vi ønsker dobbelttype pseudo-tilfældige værdier i vores applikation. Ellers kan vi bruge den tilfældige klasse, som har flere metoder til at generere pseudo-tilfældige heltal af forskellig slags, herunder nextInt(), nextLong(), nextFloat() og nextDouble().

Konklusion

For at generere en pseudo-tilfældig dobbeltværdi mellem 0,0 og 1,0 i Java, skal du bruge Math.random()-metoden i Math-klassen. Math.random() genererer en tilfældig værdi. Derfor vil den generere et andet nummer hver gang et program køres.

En tilfældig værdi kan oprettes inden for et defineret område ved hjælp af Math.random()-metoden. Denne artikel har udforsket flere funktioner i Math.random()-funktionen, herunder hvad den er, hvad den returnerer, hvordan man definerer et specifikt interval for de tilfældige heltal, og hvordan man bruger Math.random()-metoden i Java.


Java tag