Comment générer des entiers aléatoires dans une plage spécifique en Java?
Comment générer une valeur int aléatoire dans une plage spécifique?
J'ai essayé les solutions suivantes, mais celles-ci ne fonctionnent pas:
Tentative 1:
randomNum = minimum + (int)(Math.random() * maximum);
// Bug: `randomNum` can be bigger than `maximum`.
Tentative 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`.
Dans Java 1.7 ou version ultérieure, la méthode standard pour ce faire est la suivante:
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);
Voir le JavaDoc correspondant . Cette approche présente l’avantage de ne pas avoir besoin d’initialiser explicitement une Java.util.Random instance, ce qui peut être source de confusion et d’erreur s’il est utilisé de manière inappropriée.
Toutefois, à l’inverse, il n’existe aucun moyen de définir explicitement la valeur de départ, de sorte qu’il peut être difficile de reproduire les résultats dans des situations où cela est utile, comme tester ou sauvegarder des états de jeu ou similaires. Dans ces situations, la technique antérieure à Java 1.7 indiquée ci-dessous peut être utilisée.
Avant Java 1.7, la méthode standard pour ce faire est la suivante:
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;
}
Voir le JavaDoc correspondant . En pratique, la classe Java.util.Random est souvent préférable à Java.lang.Math.random () .
En particulier, il n’est pas nécessaire de réinventer la roue de génération d’entiers aléatoires s’il existe une API simple dans la bibliothèque standard pour accomplir la tâche.
Notez que cette approche est plus biaisée et moins efficace qu'une approche nextInt, https://stackoverflow.com/a/738651/360211
Un modèle standard pour accomplir ceci est:
Min + (int)(Math.random() * ((Max - Min) + 1))
La fonction de bibliothèque Java Math Math.random () génère une valeur double dans la plage [0,1). Notez que cette plage n'inclut pas le 1.
Afin d’obtenir d’abord une plage de valeurs spécifique, vous devez multiplier par la magnitude de la plage de valeurs que vous souhaitez couvrir.
Math.random() * ( Max - Min )
Cela renvoie une valeur dans la plage [0,Max-Min), où 'Max-Min' n'est pas inclus.
Par exemple, si vous voulez [5,10), vous devez couvrir cinq valeurs entières pour pouvoir utiliser
Math.random() * 5
Cela renverrait une valeur dans la plage [0,5), où 5 n'est pas inclus.
Vous devez maintenant déplacer cette plage vers la plage que vous ciblez. Vous faites cela en ajoutant la valeur Min.
Min + (Math.random() * (Max - Min))
Vous allez maintenant obtenir une valeur dans la plage [Min,Max). En suivant notre exemple, cela signifie [5,10):
5 + (Math.random() * (10 - 5))
Mais cela n'inclut toujours pas Max et vous obtenez une double valeur. Pour que la valeur Max soit incluse, vous devez ajouter 1 à votre paramètre de plage (Max - Min), puis tronquer la partie décimale en convertissant en un int. Ceci est accompli via:
Min + (int)(Math.random() * ((Max - Min) + 1))
Et voila. Une valeur entière aléatoire dans la plage [Min,Max] ou selon l'exemple [5,10]:
5 + (int)(Math.random() * ((10 - 5) + 1))
Utilisation:
Random ran = new Random();
int x = ran.nextInt(6) + 5;
Le nombre entier x est maintenant le nombre aléatoire ayant un résultat possible de 5-10.
Utilisation:
minimum + rn.nextInt(maxValue - minvalue + 1)
Avec Java-8 , ils ont introduit la méthode ints(int randomNumberOrigin, int randomNumberBound) dans la Random class.
Par exemple, si vous voulez générer cinq entiers aléatoires (ou un seul) dans l'intervalle [0, 10], faites simplement:
Random r = new Random();
int[] fiveRandomNumbers = r.ints(5, 0, 11).toArray();
int randomNumber = r.ints(1, 0, 11).findFirst().getAsInt();
Le premier paramètre indique uniquement la taille de la IntStream générée (qui est la méthode surchargée de celle qui produit une IntStream illimitée).
Si vous devez faire plusieurs appels séparés, vous pouvez créer un itérateur primitif infini à partir du 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();
}
}
Vous pouvez également le faire pour les valeurs double et long.
J'espère que ça aide! :)
Vous pouvez modifier votre deuxième exemple de code pour:
Random rn = new Random();
int range = maximum - minimum + 1;
int randomNum = rn.nextInt(range) + minimum;
Une simple modification de votre première solution suffirait.
Random Rand = new Random();
randomNum = minimum + Rand.nextInt((maximum - minimum) + 1);
Voir plus ici pour la mise en oeuvre de Random
ThreadLocalRandom équivalent de la classe Java.util.Random pour un environnement multithread. La génération d'un nombre aléatoire est effectuée localement dans chacun des threads. Nous avons donc une meilleure performance en réduisant les conflits.
int Rand = ThreadLocalRandom.current().nextInt(x,y);
x, y - intervalles, par ex. (1,10)
La classe Math.Random dans Java est basée sur 0. Donc, si vous écrivez quelque chose comme ceci:
Random Rand = new Random();
int x = Rand.nextInt(10);
x sera compris entre 0-9 inclus.
Donc, étant donné le tableau suivant d'éléments 25, le code permettant de générer un nombre aléatoire compris entre 0 (la base du tableau) et array.length serait:
String[] i = new String[25];
Random Rand = new Random();
int index = 0;
index = Rand.nextInt( i.length );
Puisque i.length retournera 25, le nextInt( i.length ) renverra un nombre compris entre 0-24. L'autre option est d'utiliser Math.Random qui fonctionne de la même manière.
index = (int) Math.floor(Math.random() * i.length);
Pour une meilleure compréhension, consultez le post du forum Random Intervals (archive.org).
Pardonnez-moi d’être fastidieux, mais la solution suggérée par la majorité, à savoir min + rng.nextInt(max - min + 1)), semble périlleuse du fait que:
rng.nextInt(n)ne peut pas atteindreInteger.MAX_VALUE.(max - min)peut provoquer un débordement lorsqueminest négatif.
Une solution infaillible renverrait des résultats corrects pour tout min <= max entre [Integer.MIN_VALUE, Integer.MAX_VALUE]. Considérez l'implémentation naïve suivante:
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;
}
Bien que peu efficace, notez que la probabilité de succès dans la boucle while sera toujours égale ou supérieure à 50%.
Je me demande si l’une des méthodes de génération de nombres aléatoires fournies par une bibliothèque { Apache Commons Math } ne conviendrait pas.
Par exemple: RandomDataGenerator.nextInt ou RandomDataGenerator.nextLong
Prenons un exemple.
Supposons que je souhaite générer un nombre compris entre 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);
Laissez-nous comprendre ceci ...
Initialiser max avec la valeur la plus élevée et min avec la valeur la plus basse.
Maintenant, nous devons déterminer combien de valeurs possibles peuvent être obtenues. Pour cet exemple, ce serait:
5, 6, 7, 8, 9, 10
Donc, le nombre de ceci serait max - min + 1.
c'est-à-dire 10 - 5 + 1 = 6
Le nombre aléatoire générera un nombre compris entre 0-5 .
c'est-à-dire 0, 1, 2, 3, 4, 5
Ajouter la valeur min au nombre aléatoire donnerait:
5, 6, 7, 8, 9, 10
Par conséquent, nous obtenons la plage souhaitée.
Rand.nextInt((max+1) - min) + min;
Générez un nombre aléatoire pour la différence entre min et max en utilisant la méthode nextint (n) , puis ajoutez un nombre min au résultat:
Random rn = new Random();
int result = rn.nextInt(max - min + 1) + min;
System.out.println(result);
Depuis Java 7, vous ne devriez plus utiliser
Random. Pour la plupart des utilisations, le Le générateur de nombre aléatoire de choix est maintenantThreadLocalRandom.
Pour joindre des piscines et parallèle ruisseaux, utilisezSplittableRandom.
Joshua Bloch. Java efficace. Troisième édition.
À partir de Java 8
Pour les pools de jointure fork et les flux parallèles, utilisez SplittableRandom qui est généralement plus rapide, présente une meilleure indépendance statistique et des propriétés d'uniformité supérieures à celles de Random.
Pour générer une int aléatoire dans la plage [0, 1_000]:
int n = new SplittableRandom().nextInt(0, 1_001);
Pour générer un tableau int[100] aléatoire de valeurs dans la plage [0, 1_000]:
int[] a = new SplittableRandom().ints(100, 0, 1_001).parallel().toArray();
Pour renvoyer un flux de valeurs aléatoires:
IntStream stream = new SplittableRandom().ints(100, 0, 1_001);
Si vous lancez un dé, il s'agira d'un nombre aléatoire compris entre 1 et 6 (et non de 0 à 6), ainsi:
face = 1 + randomNumbers.nextInt(6);
Voici une classe utile pour générer une variable aléatoire ints dans une plage comportant toute combinaison de bornes inclusives/exclusives:
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;
}
}
int random = minimum + Double.valueOf(Math.random()*(maximum-minimum )).intValue();
Ou jetez un oeil à RandomUtils de Apache Commons .
Pour générer un nombre aléatoire "entre deux nombres", utilisez le code suivant:
Random r = new Random();
int lowerBound = 1;
int upperBound = 11;
int result = r.nextInt(upperBound-lowerBound) + lowerBound;
Cela vous donne un nombre aléatoire compris entre 1 (inclus) et 11 (exclusif), donc initialisez la valeur upperBound en ajoutant 1. Par exemple, si vous souhaitez générer un nombre aléatoire compris entre 1 et 10, initialisez le nombre supérieurBound avec 11 au lieu de dix.
Cette méthode peut être pratique à utiliser:
Cette méthode retournera un nombre aléatoireentreles valeurs min et max fournies:
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;
}
}
et cette méthode retournera un nombre aléatoiredeles valeurs min et max fournies (ainsi, le nombre généré pourrait également être le nombre min ou max):
public static int getRandomNumberFrom(int min, int max) {
Random foo = new Random();
int randomNumber = foo.nextInt((max + 1) - min) + min;
return randomNumber;
}
Il suffit d'utiliser le Random class:
Random ran = new Random();
// Assumes max and min are non-negative.
int randomInt = min + ran.nextInt(max - min + 1);
J'ai trouvé cet exemple Générer des nombres aléatoires :
Cet exemple génère des entiers aléatoires dans une plage spécifique.
import Java.util.Random;
/** Generate random integers in a certain range. */
public final class RandomRange {
public static final void main(String... aArgs){
log("Generating random integers in the range 1..10.");
int START = 1;
int END = 10;
Random random = new Random();
for (int idx = 1; idx <= 10; ++idx){
showRandomInteger(START, END, random);
}
log("Done.");
}
private static void showRandomInteger(int aStart, int aEnd, Random aRandom){
if ( aStart > aEnd ) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
//get the range, casting to long to avoid overflow problems
long range = (long)aEnd - (long)aStart + 1;
// compute a fraction of the range, 0 <= frac < range
long fraction = (long)(range * aRandom.nextDouble());
int randomNumber = (int)(fraction + aStart);
log("Generated : " + randomNumber);
}
private static void log(String aMessage){
System.out.println(aMessage);
}
}
Un exemple d'exécution de cette classe:
Generating random integers in the range 1..10.
Generated : 9
Generated : 3
Generated : 3
Generated : 9
Generated : 4
Generated : 1
Generated : 3
Generated : 9
Generated : 10
Generated : 10
Done.
Vous pouvez y parvenir de manière concise dans Java 8:
Random random = new Random();
int max = 10;
int min = 5;
int totalNumber = 10;
IntStream stream = random.ints(totalNumber, min, max);
stream.forEach(System.out::println);
Lorsque vous avez besoin de beaucoup de nombres aléatoires, je ne recommande pas la classe Random dans l'API. La période est trop courte. Essayez le twister Mersenne à la place. Il y a une implémentation Java .
public static Random RANDOM = new Random(System.nanoTime());
public static final float random(final float pMin, final float pMax) {
return pMin + RANDOM.nextFloat() * (pMax - pMin);
}
Une autre option consiste simplement à utiliser Apache Commons :
import org.Apache.commons.math.random.RandomData;
import org.Apache.commons.math.random.RandomDataImpl;
public void method() {
RandomData randomData = new RandomDataImpl();
int number = randomData.nextInt(5, 10);
// ...
}
Voici un exemple simple qui montre comment générer un nombre aléatoire à partir d'une plage [min, max] fermée, alors que min <= max is true
Vous pouvez le réutiliser comme champ dans la classe de trou, en ayant également toutes les méthodes Random.class au même endroit.
Exemple de résultat:
RandomUtils random = new RandomUtils();
random.nextInt(0, 0); // returns 0
random.nextInt(10, 10); // returns 10
random.nextInt(-10, 10); // returns numbers from -10 to 10 (-10, -9....9, 10)
random.nextInt(10, -10); // throws assert
Sources:
import junit.framework.Assert;
import Java.util.Random;
public class RandomUtils extends Random {
/**
* @param min generated value. Can't be > then max
* @param max generated value
* @return values in closed range [min, max].
*/
public int nextInt(int min, int max) {
Assert.assertFalse("min can't be > then max; values:[" + min + ", " + max + "]", min > max);
if (min == max) {
return max;
}
return nextInt(max - min + 1) + min;
}
}
private static Random random = new Random();
public static int getRandomInt(int min, int max){
return random.nextInt(max - min + 1) + min;
}
OR
public static int getRandomInt(Random random, int min, int max)
{
return random.nextInt(max - min + 1) + min;
}
Si vous voulez essayer la réponse avec le plus grand nombre de votes ci-dessus, vous pouvez simplement utiliser ce code:
public class Randomizer
{
public static int generate(int min,int max)
{
return min + (int)(Math.random() * ((max - min) + 1));
}
public static void main(String[] args)
{
System.out.println(Randomizer.generate(0,10));
}
}
C'est juste propre et simple.
Il vaut mieux utiliser SecureRandom plutôt que simplement Random.
public static int generateRandomInteger(int min, int max) {
SecureRandom Rand = new SecureRandom();
Rand.setSeed(new Date().getTime());
int randomNum = Rand.nextInt((max - min) + 1) + min;
return randomNum;
}
Rand.nextInt((max+1) - min) + min;
Cela fonctionne bien.
J'utilise ceci:
/**
* @param min - The minimum.
* @param max - The maximum.
* @return A random double between these numbers (inclusive the minimum and maximum).
*/
public static double getRandom(double min, double max) {
return (Math.random() * (max+1-min)) + min;
}
Vous pouvez le convertir en Integer si vous le souhaitez.
import Java.util.Random;
public class RandomUtil {
// Declare as class variable so that it is not re-seeded every call
private static Random random = new Random();
/**
* Returns a psuedo-random number between min and max (both inclusive)
* @param min Minimim value
* @param max Maximim value. Must be greater than min.
* @return Integer between min and max (both inclusive)
* @see Java.util.Random#nextInt(int)
*/
public static int nextInt(int min, int max) {
// nextInt is normally exclusive of the top value,
// so add 1 to make it inclusive
return random.nextInt((max - min) + 1) + min;
}
}
Vous pouvez faire quelque chose comme ça:
import Java.awt.*;
import Java.io.*;
import Java.util.*;
import Java.math.*;
public class Test {
public static void main(String[] args) {
int first, second;
Scanner myScanner = new Scanner(System.in);
System.out.println("Enter first integer: ");
int numOne;
numOne = myScanner.nextInt();
System.out.println("You have keyed in " + numOne);
System.out.println("Enter second integer: ");
int numTwo;
numTwo = myScanner.nextInt();
System.out.println("You have keyed in " + numTwo);
Random generator = new Random();
int num = (int)(Math.random()*numTwo);
System.out.println("Random number: " + ((num>numOne)?num:numOne+num));
}
}
Vous pouvez utiliser cet extrait de code qui résoudra votre problème:
Random r = new Random();
int myRandomNumber = 0;
myRandomNumber = r.nextInt(maxValue-minValue+1)+minValue;
Utilisez myRandomNumber (qui vous donnera un nombre compris dans une plage).
Une approche différente avec Java 8 IntStream et Collections.shuffle
import Java.util.stream.IntStream;
import Java.util.ArrayList;
import Java.util.Collections;
public class Main {
public static void main(String[] args) {
IntStream range = IntStream.rangeClosed(5,10);
ArrayList<Integer> ls = new ArrayList<Integer>();
//populate the ArrayList
range.forEach(i -> ls.add(new Integer(i)) );
//perform a random shuffle using the Collections Fisher-Yates shuffle
Collections.shuffle(ls);
System.out.println(ls);
}
}
L'équivalent en Scala
import scala.util.Random
object RandomRange extends App{
val x = Random.shuffle(5 to 10)
println(x)
}
Je vais simplement exposer ce qui ne va pas avec les solutions fournies par la question et pourquoi les erreurs.
Solution 1:
randomNum = minimum + (int)(Math.random()*maximum);
Problème: randomNum se voit attribuer des valeurs plus grandes que maximum.
Explication: Supposons que notre minimum est 5 et que votre maximum soit 10. Toute valeur de Math.random() supérieure à 0,6 fera évaluer l'expression à 6 ou plus, et ajouter 5 le fera supérieur à 10 (votre maximum). Le problème est que vous multipliez le nombre aléatoire par le maximum (ce qui génère un nombre presque aussi grand que le maximum), puis vous ajoutez le minimum. À moins que le minimum soit 1, ce n'est pas correct. Vous devez passer à, comme mentionné dans d'autres réponses
randomNum = minimum + (int)(Math.random()*(maximum-minimum+1))
Le +1 est parce que Math.random() ne retournera jamais 1.0.
Solution 2:
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt() % n;
randomNum = minimum + i;
Votre problème ici est que '%' peut renvoyer un nombre négatif si le premier terme est inférieur à 0. Étant donné que rn.nextInt() renvoie des valeurs négatives avec une probabilité de ~ 50%, vous n'obtiendrez pas le résultat attendu.
C'était pourtant presque parfait. Il suffit de regarder un peu plus loin dans la Javadoc, nextInt (int n) . Avec cette méthode disponible, faire
Random rn = new Random();
int n = maximum - minimum + 1;
int i = rn.nextInt(n);
randomNum = minimum + i;
Renverrait également le résultat souhaité.
Random random = new Random();
int max = 10;
int min = 3;
int randomNum = random.nextInt(max) % (max - min + 1) + min;
Vous pourriez utiliser
RandomStringUtils.randomNumeric(int count)
méthode également qui est de Apache commons.
import Java.util.Random;
public class RandomSSNTest {
public static void main(String args[]) {
generateDummySSNNumber();
}
//831-33-6049
public static void generateDummySSNNumber() {
Random random = new Random();
int id1 = random.nextInt(1000);//3
int id2 = random.nextInt(100);//2
int id3 = random.nextInt(10000);//4
System.out.print((id1+"-"+id2+"-"+id3));
}
}
Vous pouvez aussi utiliser
import Java.util.concurrent.ThreadLocalRandom;
Random random = ThreadLocalRandom.current();
Cependant, cette classe ne fonctionne pas bien dans un environnement multi-thread.
Faire le changement suivant dans Tentative 1 devrait faire le travail -
randomNum = minimum + (int)(Math.random() * (maximum - minimum) );
Vérifiez this pour le code de travail.
Je pense normaliser linéairement les nombres aléatoires générés dans la plage désirée en utilisant ce qui suit. Soit x un nombre aléatoire, soit a et b les plages minimale et maximale du nombre normalisé souhaité.
Ensuite, vous trouverez ci-dessous un extrait de code très simple permettant de tester la plage produite par le mappage linéaire.
public static void main(String[] args) {
int a = 100;
int b = 1000;
int lowest = b;
int highest = a;
int count = 100000;
Random random = new Random();
for (int i = 0; i < count; i++) {
int nextNumber = (int) ((Math.abs(random.nextDouble()) * (b - a))) + a;
if (nextNumber < a || nextNumber > b) {
System.err.println("number not in range :" + nextNumber);
}
else {
System.out.println(nextNumber);
}
if (nextNumber < lowest) {
lowest = nextNumber;
}
if (nextNumber > highest) {
highest = nextNumber;
}
}
System.out.println("Produced " + count + " numbers from " + lowest
+ " to " + highest);
}
Je viens de générer un nombre aléatoire à l'aide de Math.random () et de le multiplier par un grand nombre, par exemple 10000. Ainsi, je reçois un nombre compris entre 0 et 10 000 et appelle ce nombre i. Maintenant, si j'ai besoin de nombres compris entre (x, y), procédez comme suit:
i = x + (i % (y - x));
Ainsi, tous les i sont des nombres entre x et y.
Pour supprimer le biais indiqué dans les commentaires, plutôt que de le multiplier par 10 000 (ou le grand nombre), multipliez-le par (y-x).
Je pense que ce code fonctionnera pour cela. S'il vous plaît essayez ceci:
import Java.util.Random;
public final class RandomNumber {
public static final void main(String... aArgs) {
log("Generating 10 random integers in range 1..10.");
int START = 1;
int END = 10;
Random randomGenerator = new Random();
for (int idx=1; idx<=10; ++idx) {
// int randomInt=randomGenerator.nextInt(100);
// log("Generated : " + randomInt);
showRandomInteger(START,END,randomGenerator);
}
log("Done");
}
private static void log(String aMessage) {
System.out.println(aMessage);
}
private static void showRandomInteger(int aStart, int aEnd, Random aRandom) {
if (aStart > aEnd) {
throw new IllegalArgumentException("Start cannot exceed End.");
}
long range = (long)aEnd - (long)aStart + 1;
long fraction = (long) (range * aRandom.nextDouble());
int randomNumber = (int) (fraction + aStart);
log("Generated" + randomNumber);
}
}
Si vous utilisez déjà Commons Lang API 2.x ou la dernière version, il existe une classe pour la génération de nombres aléatoires RandomUtils.
public static int nextInt(int n)
Renvoie une valeur int pseudo-aléatoire, uniformément répartie, entre 0 (inclus) et la valeur spécifiée (exclusif), à partir de la séquence Math.random ().
Paramètres: n - valeur maximale exclusive spécifiée
int random = RandomUtils.nextInt(1000000);
Remarque: Dans RandomUtils dispose de nombreuses méthodes pour générer des nombres aléatoires.
Le code ci-dessous génère un nombre aléatoire compris entre 100 000 et 900 000. Ce code générera des valeurs à six chiffres. J'utilise ce code pour générer un OTP à six chiffres.
Utilisez import Java.util.Random pour utiliser cette méthode aléatoire.
import Java.util.Random;
// Six digits random number generation for OTP
Random rnd = new Random();
long longregisterOTP = 100000 + rnd.nextInt(900000);
System.out.println(longregisterOTP);
Vous pouvez utiliser la classe Random pour générer un nombre aléatoire, puis utiliser le .nextInt (maxNumber) pour générer un nombre aléatoire. MaxNumber est le nombre que vous voulez au maximum lorsque vous générez un nombre aléatoire. Rappelez-vous cependant que la classe Random vous donne les nombres de 0 à maxNumber-1.
Random r = new Random();
int i = r.nextInt();
Une autre façon de faire consiste à utiliser la classe Math.Random (), que de nombreuses classes dans les écoles vous demandent d'utiliser car elle est plus efficace et vous n'avez pas à déclarer un nouvel objet Random. Pour obtenir un nombre aléatoire à l'aide de Math.Random (), vous devez taper:
Math.random() * (max - min) + min;
Cela générera Liste de nombres aléatoires avec plage (Min - Max) avec pas de duplication .
generateRandomListNoDuplicate(1000, 8000, 500);
Ajoutez cette méthode.
private void generateRandomListNoDuplicate(int min, int max, int totalNoRequired) {
Random rng = new Random();
Set<Integer> generatedList = new LinkedHashSet<>();
while (generatedList.size() < totalNoRequired) {
Integer radnomInt = rng.nextInt(max - min + 1) + min;
generatedList.add(radnomInt);
}
}
J'espère que ceci vous aidera.
J'ai créé une méthode pour obtenir un entier unique dans une plage donnée.
/*
* minNum is the minimum possible random number
* maxNum is the maximum possible random number
* numbersNeeded is the quantity of random number required
* the give method provides you with unique random number between min & max range
*/
public static Set<Integer> getUniqueRandomNumbers( int minNum , int maxNum ,int numbersNeeded ){
if(minNum >= maxNum)
throw new IllegalArgumentException("maxNum must be greater than minNum");
if(! (numbersNeeded > (maxNum - minNum + 1) ))
throw new IllegalArgumentException("numberNeeded must be greater then difference b/w (max- min +1)");
Random rng = new Random(); // Ideally just create one instance globally
// Note: use LinkedHashSet to maintain insertion order
Set<Integer> generated = new LinkedHashSet<Integer>();
while (generated.size() < numbersNeeded)
{
Integer next = rng.nextInt((maxNum - minNum) + 1) + minNum;
// As we're adding to a set, this will automatically do a containment check
generated.add(next);
}
return generated;
}
Supposons que vous souhaitiez une plage entre 0 et 9, 0 étant le minimum et 9 le maximum. La fonction ci-dessous imprimera n'importe quoi entre 0 et 9. C'est la même chose pour toutes les gammes.
public static void main(String[] args) {
int b = randomNumberRange(0, 9);
int d = randomNumberRange (100, 200);
System.out.println("value of b is " + b);
System.out.println("value of d is " + d);
}
public static int randomNumberRange(int min, int max) {
int n = (max + 1 - min) + min;
return (int) (Math.random() * n);
}
Un de mes amis m'avait posé la même question à l'université aujourd'hui (il souhaitait générer un nombre aléatoire compris entre 1 et -1). Alors j'ai écrit ça, et ça marche très bien avec mes tests. Idéalement, il y a beaucoup de façons de générer des nombres aléatoires en fonction d'une plage. Essaye ça:
Une fonction:
private static float getRandomNumberBetween(float numberOne, float numberTwo) throws Exception{
if (numberOne == numberTwo){
throw new Exception("Both the numbers can not be equal");
}
float Rand = (float) Math.random();
float highRange = Math.max(numberOne, numberTwo);
float lowRange = Math.min(numberOne, numberTwo);
float lowRand = (float) Math.floor(Rand-1);
float highRand = (float) Math.ceil(Rand+1);
float genRand = (highRange-lowRange)*((Rand-lowRand)/(highRand-lowRand))+lowRange;
return genRand;
}
Exécutez comme ceci:
System.out.println( getRandomNumberBetween(1,-1));
Voici un autre exemple utilisant Random et forEach
int firstNum = 20;//Inclusive
int lastNum = 50;//Exclusive
int streamSize = 10;
Random num = new Random().ints(10, 20, 50).forEach(System.out::println);
Il existe une bibliothèque sur https://sourceforge.net/projects/stochunit/ pour gérer la sélection des plages.
StochIntegerSelector randomIntegerSelector = new StochIntegerSelector();
randomIntegerSelector.setMin(-1);
randomIntegerSelector.setMax(1);
Integer selectInteger = randomIntegerSelector.selectInteger();
Il a Edge inclusion/anticlusion.
Un moyen simple de générer n nombres aléatoires entre a et b Par exemple a = 90, b = 100, n = 20
Random r = new Random();
for(int i =0; i<20; i++){
System.out.println(r.ints(90, 100).iterator().nextInt());
}
r.ints() retourne une IntStream et a plusieurs méthodes utiles, regardez son API .
Essayez d'utiliser la classe org.Apache.commons.lang.RandomStringUtils. Oui, cela donne parfois un nombre répété de manière adjacente, mais cela donnera la valeur entre 5 et 15:
while (true)
{
int abc = Integer.valueOf(RandomStringUtils.randomNumeric(1));
int cd = Integer.valueOf(RandomStringUtils.randomNumeric(2));
if ((cd-abc) >= 5 && (cd-abc) <= 15)
{
System.out.println(cd-abc);
break;
}
}
Nombre aléatoire de l'intervalle [min..max] inclus:
int randomFromMinToMaxInclusive = ThreadLocalRandom.current()
.nextInt(min, max + 1);
Utilisez Java.util pour Random pour une utilisation générale.
Vous pouvez définir votre plage minimale et maximale pour obtenir ces résultats.
Random Rand=new Random();
Rand.nextInt((max+1) - min) + min;
La plupart des suggestions ci-dessus ne prennent pas en compte le «dépassement de capacité», par exemple: min = Integer.MIN_VALUE, max = 100. L'une des approches correctes que j'ai jusqu'à présent est la suivante:
final long mod = max- min + 1L;
final int next = (int) (Math.abs(Rand.nextLong() % mod) + min);
C'est le moyen facile de le faire.
import Java.util.Random;
class Example{
public static void main(String args[]){
/*-To test-
for(int i = 1 ;i<20 ; i++){
System.out.print(randomnumber()+",");
}
*/
int randomnumber = randomnumber();
}
public static int randomnumber(){
Random Rand = new Random();
int randomNum = Rand.nextInt(6) + 5;
return randomNum;
}
}
Là se trouve le point de départ des nombres aléatoires. 6 est la plage comprenant le numéro 5.
voici une fonction qui renvoie exactement un nombre entier entier aléatoire dans une plage définie parlowerBoundIncludedetupperBoundIncluded, comme demandé par = utilisateur42155
SplittableRandom splittableRandom = new SplittableRandom();
BiFunction<Integer,Integer,Integer> randomInt = (lowerBoundIncluded, upperBoundIncluded)
-> splittableRandom.nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
randomInt.apply( …, … ); // gets the random number
… ou plus court pour la génération ponctuelle d'un nombre aléatoire
new SplittableRandom().nextInt( lowerBoundIncluded, upperBoundIncluded + 1 );
public static void main(String[] args) {
Random ran = new Random();
int min, max;
Scanner sc = new Scanner(System.in);
System.out.println("Enter min range:");
min = sc.nextInt();
System.out.println("Enter max range:");
max = sc.nextInt();
int num = ran.nextInt(min);
int num1 = ran.nextInt(max);
System.out.println("Random Number between given range is " + num1);
}
Utilisez math.random() et définissez les exigences dans l'instruction if. L'approche la plus simple, la plus simple et la plus rapide
Utilisation de Java 8 Streams,
- Passer la capacité initiale - Combien de nombres
- Passer le randomBound - de x à randomBound
- Passe vrai/faux pour trié ou pas
- Passer un nouvel objet Random ()
public static List<Integer> generateNumbers(int initialCapacity, int randomBound, Boolean sorted, Random random) {
List<Integer> numbers = random.ints(initialCapacity, 1, randomBound).boxed().collect(Collectors.toList());
if (sorted)
numbers.sort(null);
return numbers;
}
Il génère des nombres à partir de 1-Randombound dans cet exemple.
Vous trouverez ci-dessous un exemple de classe montrant comment générer des entiers aléatoires dans une plage spécifique. Attribuez la valeur maximale à la variable 'max' à votre guise et la valeur minimale à la variable 'min'.
public class RandomTestClass {
public static void main(String[] args) {
Random r = new Random();
int max = 10;
int min = 5;
int x;
x = r.nextInt(max) + min;
System.out.println(x);
}
}
Le code suivant pourrait être utilisé:
ThreadLocalRandom.current().nextInt(rangeStart, rangeEndExclusive)