nextint - random double java




Comment générer des entiers aléatoires dans une plage spécifique en Java? (20)

Depuis Java 7, vous ne devriez plus utiliser Random . Pour la plupart des utilisations, le générateur de nombre aléatoire de choix est désormais ThreadLocalRandom .

Pour les pools de jointure fork et les flux parallèles, utilisez SplittableRandom .

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, offre une meilleure indépendance statistique et des propriétés d’uniformité supérieures à celles de Random .

Pour générer un int aléatoire dans l'intervalle [0, 1_000]:

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

Pour générer un tableau int[100] aléatoire de valeurs dans l'intervalle [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);

https://code.i-harness.com

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`.

Avec java-8 ils ont introduit la méthode ints(int randomNumberOrigin, int randomNumberBound) dans la classe Random .

Par exemple, si vous voulez générer cinq entiers aléatoires (ou un seul) dans la plage [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 IntStream généré (qui est la méthode surchargée de celle qui produit un IntStream illimité).

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 long valeurs double et long .

J'espère que ça aide! :)


En 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 instance java.util.Random , ce qui peut être source de confusion et d'erreur en cas d'utilisation inappropriée.

Cependant, à 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 aléatoire entière lorsqu'il existe une API simple dans la bibliothèque standard pour accomplir la tâche.


Générez un nombre aléatoire pour la différence entre min et max en utilisant la 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);

Il suffit d'utiliser la classe Random :

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.

La classe Math.Random en 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.

Ainsi, étant donné le tableau de 25 éléments suivant, 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 , nextInt( i.length ) renverra un nombre compris entre nextInt( i.length ) . L'autre option est d' 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) .


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 plutôt le twister Mersenne . Il existe une implémentation Java .


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 atteindre Integer.MAX_VALUE .
  • (max - min) peut provoquer un débordement lorsque min est négatif.

Une solution infaillible renverrait des résultats corrects pour tout min <= max dans [ 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%.


Prenons un exemple.

Supposons que je souhaite générer un nombre compris entre 5 et 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.

soit 10 - 5 + 1 = 6

Le nombre aléatoire générera un nombre compris entre 0 et 5 .

soit 0, 1, 2, 3, 4, 5

Ajouter la valeur min au nombre aléatoire produirait:

5, 6, 7, 8, 9, 10

Par conséquent, nous obtenons la plage souhaitée.


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.


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 exemple (1,10)


Une simple modification de votre première solution suffirait.

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

Voir plus ici pour l'implémentation de Random


Utilisation:

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

L'entier x est maintenant le nombre aléatoire ayant un résultat possible de 5-10 .


Voici un exemple simple qui montre comment générer un nombre aléatoire à partir d'une plage fermée [min, max] , tandis que min <= max is true

Vous pouvez le réutiliser en tant que champ dans la classe de trou, en ayant toutes les méthodes Random.class au même endroit.

Exemple de résultats:

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

Voici une classe utile pour générer des ints aléatoires dans une plage avec 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;
    }
}

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

 rand.nextInt((max+1) - min) + min;

private static Random random = new Random();    

public static int getRandomInt(int min, int max){
  return random.nextInt(max - min + 1) + min;
}

OU

public static int getRandomInt(Random random, int min, int max)
{
  return random.nextInt(max - min + 1) + min;
}

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




integer