Hvordan genererer jeg tilfeldige heltall innenfor et bestemt område i Java?

Hvordan genererer jeg en tilfeldig int-verdi i et bestemt område?

Jeg har prøvd følgende, men de fungerer ikke:

Forsøk 1:

randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.

Forsøk 2:

Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum =  minimum + i;
// Bug: `randomNum` can be smaller than `minimum`.
Peter Mortensen
Redigerte spørsmål 5. januar 2019 в 10:13
Programmering
java random integer
12. desember 2008 в 6:20
9 visninger

I Java 1.7 eller nyere er standardmetoden å gjøre dette på følgende måte:

import java.util.concurrent.ThreadLocalRandom;

// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
int randomNum = ThreadLocalRandom.current().nextInt(min, max + 1);

Se den relevante JavaDoc. Denne tilnærmingen har den fordelen at det ikke er nødvendig å eksplisitt initialisere en java.util.Random-instans, noe som kan være en kilde til forvirring og feil hvis det brukes på feil måte.

På den annen side er det ingen måte å eksplisitt angi seed, så det kan være vanskelig å reprodusere resultater i situasjoner der det er nyttig, for eksempel testing eller lagring av spilltilstander eller lignende. I slike situasjoner kan pre-Java 1.7-teknikken vist nedenfor brukes.

Før Java 1.7 er standardmetoden å gjøre dette på følgende måte:

import java.util.Random;

/**
 * Returns a pseudo-random number between min and max, inclusive.
 * The difference between min and max can be at most
 * <code>Integer.MAX_VALUE - 1</code>.
 *
 * @param min Minimum value
 * @param max Maximum value.  Must be greater than min.
 * @return Integer between min and max, inclusive.
 * @see java.util.Random#nextInt(int)
 */
public static int randInt(int min, int max) {

    // NOTE: This will (intentionally) not run as written so that folks
    // copy-pasting have to think about how to initialize their
    // Random instance.  Initialization of the Random instance is outside
    // the main scope of the question, but some decent options are to have
    // a field that is initialized once and then re-used as needed or to
    // use ThreadLocalRandom (if using at least Java 1.7).
    // 
    // In particular, do NOT do 'Random rand = new Random()' here or you
    // will get not very good / not very random results.
    Random rand;

    // nextInt is normally exclusive of the top value,
    // so add 1 to make it inclusive
    int randomNum = rand.nextInt((max - min) + 1) + min;

    return randomNum;
}

Se den relevante JavaDoc. I praksis er klassen java.util.Random ofte å foretrekke fremfor java.lang.Math.random().

Spesielt er det ikke nødvendig å finne opp hjulet for generering av tilfeldige heltall på nytt når det finnes et enkelt API i standardbiblioteket for å utføre oppgaven.

MultiplyByZer0
Redigert svar 14. oktober 2018 в 5:08
Kommentarer (18)

Bruk:

minimum + rn.nextInt(maxValue - minvalue + 1)
Peter Mortensen
Redigert svar 22. juni 2014 в 10:22
Kommentarer (0)
 
 rand.nextInt((max+1) - min) + min;
YCF_L
Redigert svar 20. desember 2017 в 7:34
Kommentarer (0)