Java >> Tutoriel Java >  >> Java

Comment générer des nombres aléatoires en Java

Java

En Java, divers nombres aléatoires existent, notamment des nombres entiers, flottants, doubles, longs et booléens, créés dans une plage donnée. En Java, il existe quatre techniques pour générer des nombres aléatoires.

Classe aléatoire

La première méthode consiste à utiliser une classe aléatoire. Suivez les étapes ci-dessous pour utiliser la classe aléatoire afin de générer des nombres aléatoires :

  • Importer la classe java.util.Random
  • Création d'une nouvelle classe d'instance Random en tapant Random rand =new. Aléatoire()
  • Invoquez l'une des méthodes d'objet Rand suivantes :
  • Int(upperbound) renvoie un nombre aléatoire entre 0 et upperbound-1.next
  • Float() renvoie un flottant avec une valeur comprise entre 0.0 et 1.0.
  • Double() renvoie un double avec une valeur comprise entre 0.0 et 1.0.

Générer des nombres aléatoires en Java avec des exemples

import java.util.Random;

class RandomNumberGeneration {

public static void main( String args[] ) {
  Random rand_val = new Random(); //instance of random class
  int upperbound = 30; //generating random values from 0-29
  int rand_integer = rand.nextInt(upperbound);
  double rand_double=rand_val .nextDouble();
  float rand_float=rand_val .nextFloat();

  System.out.println("Random integers from 0 to" + (upperbound-1) + " : "+ rand_integer );
  System.out.println("Random float value between 0.0 and 1.0 : "+float_random);
  System.out.println("Random double value between 0.0 and 1.0 : "+rand_double);
}
}

Utilisez ThreadLocalRandom pour générer des nombres aléatoires

Suivez les instructions ci-dessous pour créer des nombres aléatoires à l'aide de la classe ThreadLocalRandom :

  • Importer la classe java.util.concurrent
  • ThreadLocalRandom – Appelez la méthode.
  • ThreadLocalRandom.current().next est utilisé pour créer des nombres aléatoires de type int – Int()
  • ThreadLocalRandom.current.next utilise Int() pour générer un nombre aléatoire de type double () – Double()
  • ThreadLocalRandom.current().nextBoolean() est utilisé pour créer des nombres aléatoires de type booléen
import java.util.concurrent.ThreadLocalRandom;
class RandomNumberGeneration {
public static void main( String args[] ) {
// Generation of random integer values
int rand_int = ThreadLocalRandom.current().nextInt();


// Display random integers
  System.out.println("Random integer values: " + rand_int);

  // Generation of double Random values
  double rand_double = ThreadLocalRandom.current().nextDouble();

  // Display random doubles
  System.out.println("Random Double Values: " + rand_double);

  //Generating Random Boolean Values  
  boolean rand_boolean = ThreadLocalRandom.current().nextBoolean();

  // Display random booleans
  System.out.println("Random Boolean Values: " + rand_boolean);
}
}

Générateur de nombres aléatoires de Java 8

La classe Random contient désormais une nouvelle méthode int(), introduite dans Java 8. Avant d'utiliser la méthode, nous devons d'abord importer le package java.util.Random.

ints() :

Les valeurs int pseudo-aléatoires sont générées de la même manière que la méthode nextInt() est appelée. Il génère un nombre infini de valeurs entières pseudo-aléatoires.

long streamSize: ints(long streamSize): ints(long streamSize): int

La méthode analyse un paramètre de type long streamSize. Il définit le nombre de valeurs à générer. Les valeurs int pseudo-aléatoires sont générées de la même manière que la méthode nextInt() est appelée. Il renvoie également un flux de valeurs int créées au hasard. Si la taille du flux est inférieure à zéro, il lève une IllegalArgumentException.

ints(long streamSize, int randomNumberOrigin, int randomNumberBound):

Paramètres :

  • streamSize :nombre de valeurs à générer.
  • NumberOrigin :origine de chaque valeur aléatoire.
  • NumberBound :chaque nombre aléatoire a abondé.

Il génère un flux de valeurs entières pseudo-aléatoires avec l'origine et la limite données. Si l'une des conditions suivantes est remplie, il lève une IllegalArgumentException :

lié stramSize 0 origine> stramSize 0 origine> stramSize 0 origine> stramSize

Paramètres :

  • randomNumberOrigin :origine de chaque valeur aléatoire.
  • randomNumberBound :chaque valeur aléatoire est liée

Il génère un flux infini de valeurs int pseudo-aléatoires avec l'origine et la borne fournies. Si l'origine est égale ou supérieure à bound, elle produit une IllegalArgumentException. De même, les méthodes longs() et doubles() génèrent respectivement un flux de types long et double. Écrivons un programme qui utilise la méthode ints() de la classe Random pour générer un flux de nombres.

import java.util.Random;
public class RandomNumberGeneration
{
public static void main(String[] args)
{
randomInts(4);
randomInts(29, 70, 110);
//getStreamOfRandomInts(30, 120);
}
//method generating integer streams of size 4
public static void findRandomInts(int int_val)
{
Random rand_val = new Random();
rand_val.ints(int_val).forEach(System.out::println);
}
//method generating 9 integer streams between 50 to 120
public static void findRandomInts(int int_val, int int_origin, int int_bound)
{
Random rand_val = new Random();
rand_val.ints(int_val, int_origin, int_bound).forEach(System.out::println);
}
}

Utiliser la fonction Math.random

Suivez les étapes ci-dessous pour générer des entiers aléatoires à l'intérieur d'une plage à l'aide de Math.random() :

  • Déclarez la valeur minimale de la plage.
  • Déclarez la valeur maximale de la plage.

Pour produire des nombres avec les valeurs min et max incluses, utilisez la formule Math.floor(Math.random()*(max-min+1)+min). En fait, vous ne pouvez utiliser cette méthode que si vous avez besoin d'un entier aléatoire ou d'une valeur flottante.

class RandomNumberGeneration {

public static void main( String args[] ) {
  
int min_val = 250;
int max_val = 400;

//Generation of random integer values from 250 to 400

  System.out.println("Random integer values  from "+min_val+" to "+max_val+ ":");
  int rand_integer = (int)Math.floor(Math.random()*(max_val-min_val+1)+min_val);
  System.out.println(rand_integer);
}
}

Conclusion

Nous avons souvent besoin de créer des nombres aléatoires lors du développement d'applications en programmation Java. De nombreux programmes peuvent générer des nombres aléatoires, tels que l'OTP, qui valide l'utilisateur. L'implémentation des dés est l'une des meilleures illustrations des nombres aléatoires. Un nombre aléatoire est affiché entre 1 et 6 lorsque nous le lançons.


Balise Java