Il existe quatre fa?ons courantes de générer des nombres aléatoires en Java. 1. Utilisez Math.Random () pour obtenir rapidement des nombres de points flottants de 0 ~ 1, ce qui convient aux scénarios simples mais ne peut pas contr?ler les graines; 2. Utilisez la classe aléatoire pour générer plusieurs types de nombres aléatoires et les graines de réglage de support, adaptées aux scénarios qui nécessitent des tests répétés; 3. Il est recommandé d'utiliser le threadlocalrandom dans un environnement multithread, qui a de meilleures performances et pas besoin de créer des instances manuellement; 4. Lorsque les besoins de sécurité sont impliqués, la classe Secure et Securenom doit être utilisée pour fournir des garanties aléatoires plus fortes mais une vitesse plus lente.

La génération de nombres aléatoires en Java n'est pas difficile. Il peut être réalisé grace à plusieurs méthodes courantes, selon vos besoins. Par exemple, que vous souhaitiez un entier ou un numéro de point flottant, que vous ayez besoin de spécifier une plage, que vous ayez besoin de crypter et de sécuriser des nombres aléatoires, etc.

Commen?ons par plusieurs scénarios d'utilisation communs et voyons comment générer des nombres aléatoires en utilisant différentes méthodes.

Utilisez Math.random() pour obtenir rapidement un numéro de point flottant de 0 ~ 1

C'est l'un des moyens les plus simples d'adapter les scénarios où des contr?les complexes ne sont pas nécessaires. Math.random() Renvoie une valeur de double type supérieure ou égale à 0,0 et inférieure à 1,0.

 double randomvalue = math.random ();

Si vous souhaitez générer un nombre dans une plage spécifique, comme un numéro de point flottant aléatoire entre 1 et 10, vous pouvez le faire:

 Double Randombetweneonandten = math.random () * 9 1;

La signification de cette formule est: Multipliez d'abord par la différence de plage (10 - 1 = 9), puis ajoutez la valeur minimale (1).
Si vous voulez des entiers, vous pouvez faire la conversion ou l'arrondissement.

• Avantages: La méthode d'écriture est simple et peut être effectuée en une seule ligne.
• Inconvénients: une mauvaise flexibilité, ne peut pas contr?ler directement les graines et ne convient pas aux scénarios où des tests répétés sont nécessaires.

Générer des nombres aléatoires plus flexibles à l'aide de classe Random

Java fournit la classe java.util.Random , qui peut générer divers types de nombres aléatoires, y compris INT, Double, Boolean, etc., et prend en charge les graines de réglage.

 import java.util.random;

Random Rand = new Random ();
int randomnt = rand.nextint (100); // Générer entier Double RandomDouble = rand.NextDouble (); // flottait entre 0,0 et 1,0

Vous pouvez également spécifier la plage:

 int randominRange = rand.nextint (50) 20; // entier entre 20 ~ 69

• Si vous avez besoin de séquences aléatoires reproductibles (comme pour les tests), vous pouvez utiliser un constructeur avec des semences:

   Randomwithseed = nouveau aléatoire (12345);

• Prend en charge la génération de valeurs booléennes, des tableaux et même des données de streaming (Java 8)

Plus efficace dans un environnement multi-threading utilisant ThreadLocalRandom

Si vous générez des nombres aléatoires dans un programme multithread, il est recommandé d'utiliser ThreadLocalRandom , une classe d'outils introduite dans Java 7, qui est spécialement optimisée pour des environnements simultanés.

 import java.util.concurrent.threadlocalrandom;

int randomnt = threadLocalrandom.current (). NextInt (1, 101); // inclut 1, à l'exclusion de 101
double randomdouble = threadLocalrandom.current (). NextDouble (0,0, 1,0);

• Il évite le problème de plusieurs threads qui se précipitent pour la même instance Random .
• L'interface est similaire au Random , mais a de meilleures performances.
• Il n'est pas nécessaire de créer explicitement une instance, utilisez simplement current() pour obtenir l'instance du thread actuel.

Small Détails Supplément: générer des nombres aléatoires "réels"

Si votre application implique la cryptographie ou la logique liée à la sécurité, il est recommandé d'utiliser SecureRandom :

 Importer Java.Security.SeCurère et;

SecureRandom SecureRandom = new SecureRandom ();
octet [] randombytes = nouveau octet [16];
SecureRandom.NextBytes (RandomBytes); // remplit int randomnt = sécurirAndom.Nextint (100);

• Il est basé sur une source d'entropie plus forte et a une sécurité plus élevée.
• La vitesse est plus lente que le Random ordinaire, il n'est donc utilisé que lorsque cela est nécessaire.

Fondamentalement, ces méthodes de génération de nombres aléatoires Java couramment utilisées. Choisissez la méthode appropriée en fonction de votre scénario d'utilisation. Par exemple, vous pouvez utiliser Math.random() pour le développement rapide des prototypes, utiliser Random à des fins générales et utiliser ThreadLocalRandom pour des environnements simultanés. Si vous avez des exigences de sécurité élevées, utilisez SecureRandom .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!