Cum pot genera aleator numere întregi într-un interval specific în Java?

În Java 1.7 sau mai târziu, modul standard de a face acest lucru este după cum urmează:

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);

A se vedea relevante JavaDoc. Această abordare are avantajul de a nu avea nevoie pentru a inițializa în mod explicit o java.util.Aleatoare de exemplu, care poate fi o sursă de confuzie și eroare dacă este utilizat necorespunzător.

Cu toate acestea, în schimb nu există nici o modalitate de a seta în mod explicit de semințe astfel încât acesta poate fi dificil de a reproduce rezultatele în situații în care este util, cum ar fi testarea sau joc de economisire membre sau similare. În aceste situații, pre-Java 1.7 tehnica prezentată mai jos pot fi utilizate.

Înainte de Java 1.7, modul standard de a face acest lucru este după cum urmează:

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;
}

A se vedea relevante JavaDoc. În practică, java.util.Aleatoare clasă este de multe ori preferat să java.lang.Matematica.random().

În special, nu este nevoie să reinventeze număr întreg aleator generație roata atunci când există un API simplu de utilizat în biblioteca standard pentru a realiza sarcina.

Rețineți că această abordare este mult mai părtinitoare și mai puțin eficientă decât o nextInt` abordare, https://stackoverflow.com/a/738651/360211

Un model standard pentru realizarea acestui lucru este:

Min + (int)(Math.random() * ((Max - Min) + 1))

De Java Matematica funcția de bibliotecă Matematică.random() genereaza o valoare dublă în intervalul [0,1). Observați acest interval nu include 1.

În scopul de a obține un anumit interval de valori, în primul rând, aveți nevoie pentru a se multiplica de amploarea gamei de valori vrei acoperit.

Math.random() * ( Max - Min )

Acesta returnează o valoare în intervalul `[0,Max-Min), unde 'Max-Min' nu este inclus.

De exemplu, dacă vrei [5,10), aveți nevoie pentru a acoperi cinci valori întregi astfel încât să utilizați

Math.random() * 5

Acest lucru se va întoarce o valoare în intervalul [0,5), unde 5 nu este inclus.

Acum aveți nevoie pentru a schimba acest interval de până la intervalul pe care îl vizați. Puteți face acest lucru prin adăugarea valorii Min.

Min + (Math.random() * (Max - Min))

Acum va primi o valoare în intervalul [Min,Max). Urmând exemplul nostru, care înseamnă [5,10):

5 + (Math.random() * (10 - 5))

Dar, acest lucru încă nu't includ "Max." și vă sunt obtinerea o valoare dublă. În scopul de a obține "Max." valoare incluse, trebuie să adăugați 1 la gama parametru `(Max - Min) și apoi trunchia partea zecimală prin turnare la un int. Acest lucru este realizat prin intermediul:

Min + (int)(Math.random() * ((Max - Min) + 1))

Și nu-l ai. Un număr întreg aleator o valoare în intervalul [Min,Max], sau pe un exemplu [5,10]:

5 + (int)(Math.random() * ((10 - 5) + 1))

Utilizare:

Random ran = new Random();
int x = ran.nextInt(6) + 5;

Întreg " x " este acum de numere aleatoare care are un rezultat posibil de 5-10`.

Utilizare:

minimum + rn.nextInt(maxValue - minvalue + 1)

Cu [tag:java-8] au introdus metoda int(int randomNumberOrigin, int randomNumberBound) Aleatoare clasă.

De exemplu, dacă doriți pentru a genera cinci aleatoare de numere întregi (sau unul singur) în intervalul [0, 10], doar face:

Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();

Primul parametru indică doar dimensiunea IntStream generat (care este supraîncărcat metodă de cea care produce un nelimitat IntStream).

Dacă aveți nevoie pentru a face mai multe apeluri separate, puteți crea o infinitate de primitive iterator de flux:

public final class IntRandomNumberGenerator {

    private PrimitiveIterator.OfInt randomIterator;

    /**
     * Initialize a new random number generator that generates
     * random numbers in the range [min, max]
     * @param min - the min value (inclusive)
     * @param max - the max value (inclusive)
     */
    public IntRandomNumberGenerator(int min, int max) {
        randomIterator = new Random().ints(min, max + 1).iterator();
    }

    /**
     * Returns a random number in the range (min, max)
     * @return a random number in the range (min, max)
     */
    public int nextInt() {
        return randomIterator.nextInt();
    }
}

Puteți face, de asemenea, pentru "dubla" și "lung" valorile.

Sper că vă ajută! :)

Puteți edita doilea exemplu de cod pentru:

Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum =  rn.nextInt(range) + minimum;

Doar o mică modificare de prima soluție ar fi suficient.

Random rand = new Random();
randomNum = minimum + rand.nextInt((maximum - minimum) + 1);

Vezi mai multe aici pentru punerea în aplicare a Aleatoare

La Matematica.Aleatorie clasa în Java 0-based. Deci, dacă ai scrie ceva de genul:

Random rand = new Random();
int x = rand.nextInt(10);

"x" va fi între 0-9 inclusiv.

Deci, având în vedere următoarele matrice de 25 de articole, codul pentru a genera un număr aleator între " 0 " (bază de matrice) și matrice.lungimea ar fi:

String[] i = new String[25];
Random rand = new Random();
int index = 0;

index = rand.nextInt( i.length );

Din i.lungime va reveni 25", " de nextInt( am.lungimea ) va returna un număr între intervalul de 0-24. Cealaltă opțiune este de a merge cu Matematica.Aleatorie care funcționează în același mod.

index = (int) Math.floor(Math.random() * i.length);

Pentru o mai bună înțelegere, a verifica afară post pe forum Intervale Aleatorii (archive.org).

ThreadLocalRandom echivalent din clasa java.util.Aleatoare pentru mediu multithreaded. Generează un număr aleator este efectuată la nivel local în fiecare dintre fire. Deci, avem o performanță mai bună prin reducerea conflictelor.

int rand = ThreadLocalRandom.current().nextInt(x,y);

x,y - intervale de exemplu (1,10)

Iartă-mă că sunt pretențios, dar soluția sugerată de majoritate, și anume, min + rng.nextInt(max - min + 1)), pare periculoasă datorită faptului că:

• rng.nextInt(n) nu poate ajunge la Întreg.MAX_VALUE`.
• `(max - min) poate cauza overflow atunci când " min " este negativ.

Un foarte simplu de manevrat soluție ar returna rezultate corecte pentru orice min <= max în cadrul [Întreg.MIN_VALUE, număr Întreg.MAX_VALUE]. Luați în considerare următoarele naiv de implementare:

int nextIntInRange(int min, int max, Random rng) {
   if (min > max) {
      throw new IllegalArgumentException("Cannot draw random int from invalid range [" + min + ", " + max + "].");
   }
   int diff = max - min;
   if (diff >= 0 && diff != Integer.MAX_VALUE) {
      return (min + rng.nextInt(diff + 1));
   }
   int i;
   do {
      i = rng.nextInt();
   } while (i < min || i > max);
   return i;
}

Deși ineficiente, rețineți că probabilitatea de succes în anii în timp ce bucla va fi întotdeauna de 50% sau mai mare.

Acesta poate fi făcut pur și simplu a face declarația:

java Randomizer.genera(0,10); //min de la zero, max de zece

Mai jos este sursa-cod

Randomizer.java

java public class Randomizer { public static int genera(int min,int max) { reveni min + (int)(Math.random() * ((max - min) + 1)); } }

Este doar curat și simplu.

Mă întreb dacă oricare dintre numere aleatoare generarea metode oferite de o [Apache Commons Matematica][matematica] biblioteca s-ar potrivi proiectul de lege.

De exemplu: RandomDataGenerator.nextInt sau RandomDataGenerator.nextLong

Să luăm un exemplu.

Să presupunem că am dori pentru a genera un număr între 5-10:

int max = 10;
int min = 5;
int diff = max - min;
Random rn = new Random();
int i = rn.nextInt(diff + 1);
i += min;
System.out.print("The Random Number is " + i);

Să ne înțelegem acest...

Inițializa max cu valoarea cea mai mare și min cu cea mai mică valoare.

Acum, avem nevoie pentru a determina cât de multe valori posibile pot fi obținute. Pentru acest exemplu, ar fi:

5, 6, 7, 8, 9, 10

Deci, contele de acest lucru ar fi max - min + 1.

de exemplu 10 - 5 + 1 = 6

numere aleatoare va genera un număr între 0-5.

de exemplu 0, 1, 2, 3, 4, 5

Adăugarea min valoare de numere aleatoare va produce:

5, 6, 7, 8, 9, 10

prin Urmare, vom obține valorile dorite.

Genera un număr aleator pentru diferenta dintre min si max, cu ajutorul nextint(n) metoda și apoi se adaugă min număr de rezultat:

Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);

Ca de Java 7, ar trebui să nu mai utilizați "Aleator". Pentru cele mai multe utilizări, generator de numere aleatoare de alegere este acum ThreadLocalRandom.

Pentru furca se alătura piscine și paralel fluxuri, utilizarea SplittableRandom.

Joshua Bloch. Java. A Treia Ediție.

Pornind de la Java 8

Pentru furca se alătura piscine și fluxuri paralele, folosesc SplittableRandom` care este, de obicei, mai repede, are o mai bună independență statistică și uniformitatea proprietăți în comparație cu "Aleator".

Pentru a genera aleatoriu un int în intervalul [0, 1_000]:

int n = new SplittableRandom().nextInt(0, 1_001);

Pentru a genera aleatoriu un int[100] matrice de valori în intervalul [0, 1_000]:

int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();

Pentru a returna un Flux de valori aleatoare:

IntStream stream = new SplittableRandom().ints(100, 0, 1_001);

Aceste metode ar putea fi convenabil de a folosi:

Aceasta metoda va returna un număr aleator între furnizate min și max valoare:

public static int getRandomNumberBetween(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt(max - min) + min;
    if (randomNumber == min) {
        // Since the random number is between the min and max values, simply add 1
        return min + 1;
    } else {
        return randomNumber;
    }
}

si aceasta metoda va returna un număr aleator la furnizate min și max valoare (deci număr generat ar putea fi, de asemenea, min sau max număr):

public static int getRandomNumberFrom(int min, int max) {
    Random foo = new Random();
    int randomNumber = foo.nextInt((max + 1) - min) + min;

    return randomNumber;
}

În caz de rulare un zar ar fi număr aleator între 1 la 6 (nu de la 0 la 6), astfel:

face = 1 + randomNumbers.nextInt(6);

int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();

Sau de a lua o privire la RandomUtils de Apache Commons.

Aici's o clasă de ajutor pentru a genera aleatoriu int într-o gamă cu orice combinație, inclusiv/exclusiv limite:

import java.util.Random;

public class RandomRange extends Random {
    public int nextIncInc(int min, int max) {
        return nextInt(max - min + 1) + min;
    }

    public int nextExcInc(int min, int max) {
        return nextInt(max - min) + 1 + min;
    }

    public int nextExcExc(int min, int max) {
        return nextInt(max - min - 1) + 1 + min;
    }

    public int nextIncExc(int min, int max) {
        return nextInt(max - min) + min;
    }
}