Maîtriser l’utilisation de Random en Java
Sommaire
- 1- Objectifs
- 2- Introduction à la classe Random en Java
- 2.1- Présentation de la classe Random dans le package java.util.
- 2.2- Explication de pourquoi et quand utiliser des valeurs aléatoires dans les programmes.
- 3- Générer un nombre aléatoire en Java
- 3.1- Utilisation de la méthode
Math.random()
- 3.1.1- Description :
- 3.1.2- Syntaxe:
- 3.1.3- Exemple :
- 3.1.4- Activités :
- 3.2- Utilisation de laclasse
Random
- 3.2.1- Description :
- 3.2.2- Exemple :
- 3.2.3- Activité :
- 3.3- Utilisation de la classe
ThreadLocalRandom
- 3.3.1- Description :
- 3.3.2- Exemple :
- 3.3.3- Activité :
- 3.4- Utilisation de la Méthode
ints()
(dans Java 8 et plus) - 3.4.1- Description :
- 3.4.2- Exemple :
- 3.4.3- Activité :
- 4- Générer un nombre aléatoire compris entre une plage spécifiée
- 4.1- Syntaxe
- 4.2- Description
- 4.3- Exemple
- 4.4- Activités
- 4.4.1- Sommaire du cours Java
Maîtriser l’utilisation de Random en Java
-
Objectifs
- Comprendre les bases de la classe Random en Java.
- Savoir comment générer des nombres aléatoires entiers, flottants, et doubles.
- Apprendre à générer des nombres aléatoires dans une plage spécifique.
- Découvrir des techniques avancées pour générer des caractères aléatoires, des chaînes, et des séquences de nombres.
- Apprendre à utiliser ThreadLocalRandom et SecureRandom pour des besoins spécifiques.
-
Introduction à la classe Random en Java
- La classe Random fait partie du package java.util.
- Une instance de la classe Java Random est utilisée pour générer des nombres aléatoires.
Random random = new Random();
-
Présentation de la classe Random dans le package java.util.
- La classe Random fait partie du package java.util et permet de générer des nombres aléatoires dans vos programmes Java. Cette classe est très utile lorsque vous avez besoin d’introduire un élément d’aléatoire dans votre application, comme par exemple dans des jeux, des simulations ou des tests.
-
Explication de pourquoi et quand utiliser des valeurs aléatoires dans les programmes.
- Les nombres aléatoires sont très utiles dans de nombreux domaines, notamment :
- Les jeux : pour introduire de l’imprévisibilité et de la variété dans les parties.
- Les simulations : pour modéliser des phénomènes aléatoires, comme des expériences de lancer de dés ou de pièces de monnaie.
- Les tests : pour générer des données de test aléatoires et couvrir un maximum de cas possibles.
- La cryptographie : pour générer des clés de chiffrement sécurisées.
-
Générer un nombre aléatoire en Java
- En Java, il existe trois façons de générer des nombres aléatoires à l’aide de méthodes et de classes.
-
Utilisation de la méthode
Math.random()
-
Description :
- La méthode
Math.random()
est une méthode statique fournie par la classe Math qui retourne un nombre décimal aléatoire de type double, compris entre 0.0 (inclus) et 1.0 (exclus). -
Syntaxe:
- Pour obtenir un nombre entier aléatoire entre deux bornes inclusives, disons min et max, vous pouvez utiliser la formule suivante :
-
Exemple :
-
Activités :
- Créez un programme Java qui génére des nombres entiers aléatoires compris entre 1 et 100 en utilisant Math.random() et de les afficher.
- Créez un programme simple simulant le lancer de deux dés en utilisant
Math.random()
. - Créez un programme Java qui demande à l'utilisateur de saisir deux entiers positifs min et max. Le programme doit vérifier que les deux entiers sont bien positifs et que max est supérieur à min. Si ces conditions ne sont pas respectées, le programme redemandera à l'utilisateur de saisir les entiers jusqu'à ce qu'ils soient valides. Une fois les valeurs correctes obtenues, le programme génère un nombre entier aléatoire compris entre min et max (inclusivement) en utilisant Math.random() et affiche le résultat.
-
Utilisation de laclasse
Random
-
Description :
- La classe
Random
de java.util permet de générer des valeurs aléatoires plus variées, telles que des entiers, des flottants, des booléens, des longs, etc. Elle offre plus de flexibilité que Math.random(). -
Exemple :
-
Activité :
-
Utilisation de la classe
ThreadLocalRandom
-
Description :
- La classe
ThreadLocalRandom
, introduite en Java 7, est une alternative performante à Random pour les applications multithreadées. Elle est particulièrement utile pour éviter la contention des threads. -
Exemple :
-
Activité :
- Comparaison des performances : Comparez les performances de Random et ThreadLocalRandom dans un programme multi-threadé pour générer des nombres aléatoires et analysez les résultats.
- Simulation de charges de travail : Créez une simulation où plusieurs threads génèrent des nombres aléatoires pour modéliser un système concurrent.
-
Utilisation de la Méthode
ints()
(dans Java 8 et plus) -
Description :
- La méthode
ints()
fait partie des méthodes ajoutées à la classe Random en Java 8. Elle génère un flux (stream) de nombres entiers aléatoires, ce qui est très pratique pour les opérations fonctionnelles sur les flux. -
Exemple :
-
Activité :
- Ecrivez un programme java pour générer des flux de nombres aléatoires et d'effectuer des opérations fonctionnelles, comme filtrer les nombres pairs ou calculer leur somme.
- Créer une liste de 10 nombres aléatoires et d'en extraire les 3 plus grands en utilisant les méthodes de flux.
-
Générer un nombre aléatoire compris entre une plage spécifiée
-
Syntaxe
-
Description
- La classe Random en Java est utilisée pour générer des nombres pseudo-aléatoires. Elle offre plusieurs méthodes pour générer différents types de nombres, notamment des entiers, des flottants, des longs, etc.
random.nextInt(bound)
: Cette méthode génère un entier aléatoire compris entre 0 (inclus) et bound (exclus). Pour générer un nombre dans une plage spécifique, vous devez ajuster cette méthode pour qu'elle retourne un nombre entre min et max.(max - min) + 1
: Ceci définit la taille de la plage des valeurs possibles.+ min
: Cette opération déplace la plage de valeurs pour commencer à min au lieu de 0.-
Exemple
- Voici un exemple de code qui montre comment générer un nombre aléatoire entre 10 et 20 en utilisant la classe Random :
-
Activités
- Exercice de Base :
- Utilisez la classe Random pour générer un nombre entier aléatoire compris entre 1 et 50, puis affichez-le à l'écran.
- Jeu de Devinettes :
- Créez un programme où le programme génère un nombre aléatoire entre 1 et 100. L'utilisateur doit deviner le nombre en fournissant des entrées jusqu'à ce qu'il trouve la bonne réponse. Le programme doit donner des indices ("plus haut" ou "plus bas").
- Simulation de Lancer de Dés :
- Simulez un lancer de dé à 6 faces en utilisant random.nextInt(6) + 1. Affichez les résultats de 10 lancers.
- Défi :
- Créez une application qui génère un nombre aléatoire entre 1 et 1000. L'utilisateur doit entrer un intervalle (par exemple, min=100 et max=300), et le programme doit vérifier si le nombre aléatoire se situe dans cet intervalle.
int randomNumber = (int) (Math.random() * (max - min + 1)) + min;
public class ExempleMathRandom {
public static void main(String[] args) {
int min = 10;
int max = 50;
// Générer un nombre entier aléatoire entre min et max inclus
int randomNumber = (int) (Math.random() * (max - min + 1)) + min;
// Afficher le nombre aléatoire
System.out.println("Nombre entier aléatoire entre " + min + " et " + max + " : " + randomNumber);
}
}
Solution
public class RandomNumbers {
public static void main(String[] args) {
// Définir le nombre de nombres aléatoires à générer
int nombreDeNombres = 10;
System.out.println("Nombres aléatoires entre 1 et 100:");
for (int i = 0; i < nombreDeNombres; i++) {
// Générer un nombre aléatoire compris entre 1 et 100
int nombreAleatoire = (int) (Math.random() * 100) + 1;
// Afficher le nombre aléatoire
System.out.println(nombreAleatoire);
}
}
}
Solution
public class DiceRoll {
public static void main(String[] args) {
// Simuler le lancer du premier dé
int de1 = (int) (Math.random() * 6) + 1;
// Simuler le lancer du deuxième dé
int de2 = (int) (Math.random() * 6) + 1;
// Afficher les résultats des deux lancers
System.out.println("Lancer du premier dé : " + de1);
System.out.println("Lancer du deuxième dé : " + de2);
// Afficher la somme des deux dés
int somme = de1 + de2;
System.out.println("Somme des deux dés : " + somme);
}
}
Solution
import java.util.Scanner;
public class RandomNumberGenerator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int min, max;
// Demande des valeurs min et max avec validation
while (true) {
System.out.print("Veuillez saisir un entier positif pour min : ");
min = scanner.nextInt();
System.out.print("Veuillez saisir un entier positif pour max (doit être supérieur à min) : ");
max = scanner.nextInt();
if (min > 0 && max > 0 && max > min) {
break;
} else {
System.out.println("Erreur : Les deux entiers doivent être positifs et max doit être supérieur à min. Veuillez réessayer.");
}
}
// Générer un nombre entier aléatoire entre min et max
int randomNumber = (int) (Math.random() * (max - min + 1)) + min;
// Afficher le nombre aléatoire
System.out.println("Nombre entier aléatoire entre " + min + " et " + max + " : " + randomNumber);
scanner.close();
}
}
import java.util.Random;
public class ExempleRandom {
public static void main(String[] args) {
Random random = new Random();
int randomInt = random.nextInt(100) + 1; // Génère un entier entre 1 et 100
System.out.println("Nombre aléatoire entre 1 et 100 : " + randomInt);
}
}
import java.util.concurrent.ThreadLocalRandom;
public class ExempleThreadLocalRandom {
public static void main(String[] args) {
int randomInt = ThreadLocalRandom.current().nextInt(1, 101); // Génère un entier entre 1 et 100
System.out.println("Nombre aléatoire entre 1 et 100 : " + randomInt);
}
}
import java.util.Random;
public class ExempleIntStream {
public static void main(String[] args) {
Random random = new Random();
random.ints(5, 1, 101).forEach(System.out::println); // Génère et affiche 5 entiers aléatoires entre 1 et 100
}
}
Random random = new Random();
int nombreAleatoire = random.nextInt((max - min) + 1) + min;
import java.util.Random;
public class NombreAleatoire {
public static void main(String[] args) {
int min = 10;
int max = 20;
// Création d'un objet Random
Random random = new Random();
// Génération d'un nombre entier aléatoire entre min et max
int nombreAleatoire = random.nextInt((max - min) + 1) + min;
// Affichage du résultat
System.out.println("Nombre aléatoire entre " + min + " et " + max + " : " + nombreAleatoire);
}
}