IRandomGenerator Interface

Définition

[Android.Runtime.Register("java/util/random/RandomGenerator", "", "Java.Util.RandomGenerators.IRandomGeneratorInvoker", ApiSince=35)]
public interface IRandomGenerator : Android.Runtime.IJavaObject, IDisposable, Java.Interop.IJavaPeerable

[<Android.Runtime.Register("java/util/random/RandomGenerator", "", "Java.Util.RandomGenerators.IRandomGeneratorInvoker", ApiSince=35)>]
type IRandomGenerator = interface
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Dérivé

Java.Util.Random

Java.Util.SplittableRandom

Attributs

RegisterAttribute

Implémente

IJavaObject IJavaPeerable IDisposable

Remarques

L’interface RandomGenerator est conçue pour fournir un protocole commun pour les objets qui génèrent des séquences pseudorandom aléatoires ou (plus généralement) de nombres (ou valeurs booléennes). Une telle séquence peut être obtenue en appelant à plusieurs reprises une méthode qui retourne une valeur unique pseudorandomly choisie, ou en appelant une méthode qui retourne un flux de valeurs pseudorandomly choisies.

Dans l’idéal, étant donné une plage de valeurs implicitement ou explicitement spécifiée, chaque valeur est choisie indépendamment et uniformément à partir de cette plage. Dans la pratique, il est possible que l’on se contente d’une certaine approximation de l’indépendance et de l’uniformité.

Dans le cas de int, longet boolean de valeurs, s’il n’existe aucune spécification explicite de plage, la plage inclut toutes les valeurs possibles du type. Dans le cas et floatdouble les valeurs, une valeur est toujours choisie uniformément à partir de l’ensemble de valeurs 2^w comprises entre 0,0 (inclus) et 1,0 (exclusif), où w est Float#PRECISION pour float les valeurs et Double#PRECISION pour double les valeurs, de sorte que les valeurs adjacentes diffèrent par 2^&moins ;w (notez que ce jeu est un sous-ensemble de l’ensemble de toutes les valeurs à virgule flottante représentées comprises entre 0,0 (inclus) et 1.0 (exclusif)) ; alors si une plage explicite a été spécifiée, le nombre choisi est mis à l’échelle de manière calculée et traduit afin d’avoir été choisi approximativement uniformément à partir de cette plage explicite.

Chaque méthode qui retourne un flux produit un flux de valeurs dont chacun est choisi de la même manière que pour une méthode qui retourne une valeur pseudo-aléatoire unique. Par exemple, si r elle est implémentée RandomGenerator, l’appel r.ints(100) de méthode retourne un flux de 100 int valeurs. Il ne s’agit pas nécessairement des mêmes valeurs qui auraient été retournées si, au lieu de cela r.nextInt() , avaient été appelées 100 fois ; tout ce qui est garanti est que chaque valeur du flux est choisie de manière pseudo-random similaire à partir de la même plage.

Chaque objet qui implémente l’interface à l’aide RandomGenerator d’un algorithme pseudo-random est supposé contenir une quantité d’état finie. L’utilisation d’un tel objet pour générer une valeur pseudo-choisie modifie son état en calculant un nouvel état en tant que fonction de l’état actuel, sans référence à aucune information autre que l’état actuel. Le nombre d’états possibles distincts d’un tel objet est appelé sa période. (Certaines implémentations de l’interface RandomGenerator peuvent être vraiment aléatoires plutôt que pseudorandom, par exemple en s’appuyant sur le comportement statistique d’un objet physique pour dériver des valeurs choisies. Ces implémentations n’ont pas de période fixe.)

En règle générale, les objets qui implémentent l’interface RandomGenerator n’ont pas besoin d’être thread-safe. Il est recommandé que les applications multithread utilisent ThreadLocalRandom soit ou (de préférence) des générateurs de pseudo-nombres qui implémentent l’interface ou SplittableGenerator l’interfaceJumpableGenerator.

Les objets qui implémentent RandomGenerator ne sont généralement pas sécurisés par chiffrement. Envisagez plutôt d’utiliser SecureRandom pour obtenir un générateur de pseudo-random sécurisé par chiffrement à utiliser par les applications sensibles à la sécurité. Notez toutefois que SecureRandom cela implémente l’interface RandomGenerator afin que les instances de SecureRandom peuvent être utilisées de manière interchangeable avec d’autres types de générateurs pseudo-random dans les applications qui ne nécessitent pas de générateur sécurisé.

Sauf indication explicite contraire, l’utilisation de null pour n’importe quel argument de méthode entraîne une exception NullPointerException.

Ajouté dans 17.

Documentation Java pour java.util.random.RandomGenerator.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.