Génération de nombres aléatoires en Java dans une plage donnée : tutoriel

Nombres aléatoires en Java : du chaos à l'ordre

Bonjour, futur javiste ! Si tu as déjà écrit des jeux, des simulations, des tests ou simplement voulu ajouter un élément de surprise à ton programme, tu as sûrement été confronté à la nécessité d'obtenir un nombre entier aléatoire dans une plage donnée. Cela semble simple, non ? Mais en pratique, les débutants se demandent souvent : « Pourquoi j'obtiens des nombres de 0 à 100, et non de 50 à 100 ? » ou « Pourquoi mon code génère une erreur ? ».

Aujourd'hui, nous allons analyser ce sujet une fois pour toutes. Tu apprendras comment générer un nombre aléatoire en Java dans n'importe quelle plage, en utilisant trois approches principales. Spoiler : l'une d'elles est le meilleur choix dans 90% des cas. C'est parti !

Pourquoi est-ce important ?

La génération de nombres aléatoires est une tâche fondamentale mais cruciale. Elle est indispensable pour :

\n
• Créer des données de test (par exemple, des ID d'utilisateurs).
\n
• Implémenter des mécaniques de jeu (apparition d'objets, génération de niveaux).
\n
• Modéliser des processus aléatoires (files d'attente, trafic).
\n
• Sélectionner un élément aléatoire dans une liste.
\n

En maîtrisant ce sujet, tu cesseras de craindre la « magie » dans le code et pourras gérer l'aléatoire en toute confiance.

Méthode n°1 : La classique — java.util.Random

C'est le grand-père de tous les générateurs en Java. La classe java.util.Random existe depuis les premières versions et est encore activement utilisée. Son principal avantage est sa polyvalence.

Comment obtenir un int aléatoire de 0 à N ?

La méthode nextInt(int bound) retourne un nombre aléatoire de 0 (inclus) à bound (exclu). Autrement dit, si tu écris nextInt(10), tu obtiendras un nombre de 0 à 9.

import java.util.Random;\n\npublic class RandomExample {\n    public static void main(String[] args) {\n        Random random = new Random();\n        int number = random.nextInt(10); // 0..9\n        System.out.println("Nombre aléatoire : " + number);\n    }\n}

Et comment faire de 5 à 15 ?

C'est là que réside le grand secret. Pour obtenir un nombre dans une plage arbitraire [min, max], il faut utiliser la formule :

min + random.nextInt(max - min + 1)

Analysons avec un exemple : la plage de 5 à 15.

\n
• max - min + 1 = 15 - 5 + 1 = 11. Donc nextInt(11) donnera des nombres de 0 à 10.
\n
• On ajoute min (5) : on obtient la plage 5..15.
\n

Vérifions : si nextInt(11) retourne 0, alors 0+5 = 5. S'il retourne 10, alors 10+5 = 15. Parfait !

Random random = new Random();\nint min = 5;\nint max = 15;\nint randomNumber = min + random.nextInt(max - min + 1);\nSystem.out.println("Nombre aléatoire de 5 à 15 : " + randomNumber);

Important : N'oublie pas le +1 ! Sans lui, la valeur maximale sera inférieure de 1.

Méthode n°2 : L'approche moderne — ThreadLocalRandom

Depuis Java 7, la classe ThreadLocalRandom est apparue. Elle est spécialement conçue pour les applications multithreadées (mais fonctionne très bien aussi en monothread). Son principal avantage est qu'elle est plus rapide que Random et ne nécessite pas la création d'un objet séparé.

Utilisation en code monothread

Elle dispose d'une méthode pratique nextInt(int origin, int bound) qui accepte directement les limites de la plage ! Note bien : origin est inclusif, bound est exclusif. Si tu as besoin d'inclure la limite supérieure, ajoute simplement +1.

import java.util.concurrent.ThreadLocalRandom;\n\npublic class ThreadLocalRandomExample {\n    public static void main(String[] args) {\n        // Nombre de 5 à 15 (inclusif)\n        int randomNumber = ThreadLocalRandom.current().nextInt(5, 16);\n        System.out.println("Nombre aléatoire : " + randomNumber);\n    }\n}

Tu vois comme c'est simple ? Pas de formules,