Cum pot genera aleatoriu un int
valoarea într-un anumit interval?
Am încercat următoarele, dar alea nu merg:
Încercare de 1:
randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.
Încercare de 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`.
Î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))
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ă! :)
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`.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
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, utilizareaSplittableRandom
.
Joshua Bloch. Java. A Treia Ediție.
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;
}
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;
}
}