RandomGeneratorFactory Classe

Définition

Espace de noms:: Java.Util.RandomGenerators

Assembly:: Mono.Android.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique.

[Android.Runtime.Register("java/util/random/RandomGeneratorFactory", ApiSince=35, DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.util.random.RandomGenerator" })]
public sealed class RandomGeneratorFactory : Java.Lang.Object

[<Android.Runtime.Register("java/util/random/RandomGeneratorFactory", ApiSince=35, DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.util.random.RandomGenerator" })>]
type RandomGeneratorFactory = class
    inherit Object

Héritage: Object

JavaObject

Object
RandomGeneratorFactory

Attributs: RegisterAttribute JavaTypeParametersAttribute

Remarques

Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. RandomGeneratorFactory fournit également des méthodes pour sélectionner des algorithmes de générateur de nombres aléatoires.

Un élément spécifique RandomGeneratorFactory peut être localisé à l’aide de la RandomGeneratorFactory#of(String) méthode, où la chaîne d’argument est le nom de l’algorithme requis. La méthode RandomGeneratorFactory#all() produit un non-vide Stream de tous les éléments disponibles RandomGeneratorFactory RandomGeneratorFactorys qui peuvent être recherchés pour rechercher un RandomGeneratorFactory élément approprié à la tâche.

Il existe trois méthodes pour construire une instance RandomGenerator, en fonction du type de valeur initiale requise. RandomGeneratorFactory#create(long) est utilisé pour la construction de semences longues, RandomGeneratorFactory#create(byte[]) est utilisé pour la construction de départs d’octets[] et RandomGeneratorFactory#create() est utilisé pour la construction de départ aléatoire. Exemple ;

{@code
               RandomGeneratorFactory<RandomGenerator> factory = RandomGeneratorFactory.of("Random");

                for (int i = 0; i < 10; i++) {
                    new Thread(() -> {
                        RandomGenerator random = factory.create(100L);
                        System.out.println(random.nextDouble());
                    }).start();
                }
            }

RandomGeneratorFactory fournit également des méthodes décrivant les attributs (ou propriétés) d’un générateur et peuvent être utilisées pour sélectionner des algorithmes de générateur de nombres aléatoires. Ces méthodes sont généralement utilisées conjointement avec RandomGeneratorFactory#all(). Dans cet exemple, le code localise le RandomGeneratorFactory code qui produit RandomGenerator RandomGenerators avec le plus grand nombre de bits d’état.

{@code
                RandomGeneratorFactory<RandomGenerator> best = RandomGeneratorFactory.all()
                    .sorted(Comparator.comparingInt(RandomGenerator::stateBits).reversed())
                    .findFirst()
                    .orElse(RandomGeneratorFactory.of("Random"));
                System.out.println(best.name() + " in " + best.group() + " was selected");

                RandomGenerator rng = best.create();
                System.out.println(rng.nextLong());
            }

Ajouté dans 17.

Java documentation pour java.util.random.RandomGeneratorFactory.

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.

Propriétés

Nom	Description
Class	Retourne la classe runtime de ce `Object`. (Hérité de Object)
Default	Retourne une `RandomGeneratorFactory` réponse à l’exigence minimale d’avoir un algorithme dont les bits d’état sont supérieurs ou 64 égaux.
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
IsArbitrarilyJumpable	Retourne la valeur true si le générateur aléatoire peut sauter un point distant arbitrairement spécifié dans le cycle d’état.
IsDeprecated	Retourne true si l’implémentation de RandomGenerator (algorithme) a été marquée pour dépréciation.
IsHardware	Retourne la valeur true si le générateur aléatoire utilise un périphérique matériel (HRNG) pour produire une entrée en tropique.
IsJumpable	Retourne la valeur true si le générateur aléatoire peut sauter un point distant spécifié dans le cycle d’état.
IsLeapable	Retourne la valeur true si le générateur aléatoire est sautable et peut passer à un point très distant dans le cycle d’état.
IsSplittable	Retourne la valeur true si le générateur aléatoire peut être cloné dans un objet distinct avec les mêmes propriétés, mais placé plus loin dans le cycle d’état.
IsStatistical	Retourne la valeur true si le générateur aléatoire est calculé à l’aide d’un algorithme arithmétique et est statistiquement déterministe.
IsStochastic	Retourne la valeur true si le générateur aléatoire est calculé à l’aide de sources externes ou tropiques en tant qu’entrées.
IsStreamable	Retourne la valeur true si le générateur aléatoire peut être utilisé pour créer `java.util.stream.Stream Streams` des nombres aléatoires.
JniIdentityHashCode	Obtient le code de hachage d’identité affecté à cet homologue Java par le runtime d’interopérabilité. (Hérité de Object)
JniManagedPeerState	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
JniPeerMembers	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique.
PeerReference	Obtient la référence d’objet JNI pour cet homologue Java. (Hérité de Object)
ThresholdClass	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code. (Hérité de Object)
ThresholdType	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code. (Hérité de Object)

Méthodes

Nom	Description
Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
Construct(JniObjectReference, JniObjectReferenceOptions)	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
Create()	Créez une instance basée `RandomGenerator` sur l’algorithme choisi.
Create(Byte[])	Créez une instance basée `RandomGenerator` sur l’algorithme choisi en fournissant une valeur initiale d’octet de départ[].
Create(Int64)	Créez une instance basée `RandomGenerator` sur l’algorithme choisi en fournissant une valeur initiale de départ longue.
Dispose()	Libère les ressources détenues par cet homologue Java. (Hérité de Object)
Dispose(Boolean)	Libère les ressources détenues par cet homologue Java. (Hérité de Object)
DisposeUnlessReferenced()	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
Equals(Object)	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
Equidistribution()	Retourne l’équidistribution de l’algorithme.
GetHashCode()	Retourne une valeur de code de hachage pour l’objet. (Hérité de Object)
Group()	Retourne le nom du groupe de l’algorithme utilisé par le générateur de nombres aléatoires.
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
Name()	Retourne le nom de l’algorithme utilisé par le générateur de nombres aléatoires.
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
Of(String)	Retourne un `RandomGeneratorFactory` qui peut produire des instances de `RandomGenerator` l’algorithme qui utilisent l’algorithme `name`.
Period()	Retourne la période de l’algorithme utilisé par le générateur de nombres aléatoires.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
SetPeerReference(JniObjectReference, JniObjectReferenceOptions)	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
StateBits()	Retourne le nombre de bits utilisés par l’algorithme pour maintenir l’état de départ.
ToArray<T>()	Crée un tableau managé à partir de ce wrapper de tableau Java. (Hérité de Object)
ToString()	Retourne une représentation de chaîne de l'objet. (Hérité de Object)
UnregisterFromRuntime()	Annule l’inscription de cet homologue Java à partir du runtime d’interopérabilité. (Hérité de Object)
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti> par< em>ou <em>interrompu/em<,> ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti> par< em>ou <em>interrompu/em<,> ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)

Implémentations d’interfaces explicites

Nom	Description
IJavaPeerable.Disposed()	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
IJavaPeerable.Finalized()	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
IJavaPeerable.JniObjectReferenceControlBlock	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)
IJavaPeerable.SetPeerReference(JniObjectReference)	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique. (Hérité de JavaObject)

Méthodes d’extension

Nom	Description
GetJniTypeName(IJavaPeerable)	Obtient le nom JNI du type de l’instance `self`.
JavaAs<TResult>(IJavaPeerable)	Essayez de forcer `self` le type`TResult`, en vérifiant que le forçage est valide côté Java.
JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Il s’agit d’une classe de fabrique permettant de générer plusieurs générateurs de nombres aléatoires d’un algorithme spécifique.
TryJavaCast<TResult>(IJavaPeerable, TResult)	Essayez de forcer `self` le type`TResult`, en vérifiant que le forçage est valide côté Java.

S’applique à