Probabilité en Java
J'étais curieux de savoir, comment implémenter la probabilité en Java? Par exemple, si les chances d'une variable montrant est 1/25, alors comment pourrais-je implémenter cela? Ou de toute autre probabilité? Veuillez me diriger vers la direction générale.
5 réponses
Vous pouvez utiliser Aléatoire pour générer un nombre aléatoire, puis le tester contre un littéral pour correspondre à la probabilité que vous essayez d'atteindre.
Ainsi donné:
boolean val = new Random().nextInt(25)==0;
val aura une probabilité 1/25 d'être vrai (puisque nextInt() a une probabilité paire de retourner n'importe quel nombre commençant à 0 et jusqu'à, mais non compris, 25.)
Vous devriez bien sûr import java.util.Random; aussi.
Comme indiqué ci-dessous, si vous obtenez plus d'un nombre aléatoire, ce serait plus efficace pour réutiliser L'Objet aléatoire plutôt que de le recréer tout le temps:
Random rand = new Random();
boolean val = rand.nextInt(25)==0;
..
boolean val2 = rand.nextInt(25)==0;
Généralement, vous utilisez un générateur de nombres aléatoires. La plupart d'entre eux renvoient un nombre dans l'intervalle [0,1] de sorte que vous vérifieriez alors si ce nombre est
if( new Random().nextDouble() <= 0.04 ) { //you might want to cache the Random instance
//we hit the 1/25 ( 4% ) case.
}
Ou
if( Math.random() <= 0.04 ) {
//we hit the 1/25 ( 4% ) case.
}
Notez qu'il existe plusieurs générateurs de nombres aléatoires qui ont des propriétés différentes, mais pour les applications simples, la classe Random devrait être suffisante.
Depuis 1.7, il est préférable d'utiliser (dans un environnement concurrent au moins):
ThreadLocalRandom.current().nextInt(25) == 0
Un générateur de nombres aléatoires isolé sur le thread courant. Comme le générateur aléatoire global utilisé par la classe Math, un ThreadLocalRandom est initialisé avec une graine générée en interne qui ne peut pas autrement être modifiée. Le cas échéant, l'utilisation de ThreadLocalRandom plutôt que d'objets aléatoires partagés dans des programmes concurrents rencontrera généralement beaucoup moins de frais généraux et affirmation. L'utilisation de ThreadLocalRandom est particulièrement appropriée lorsque plusieurs tâches (par exemple, chacune a ForkJoinTask) utilisent des nombres aléatoires en parallèle dans des pools de threads. Les utilisations de cette classe doivent généralement être de la forme: ThreadLocalRandom.actuel().nextX(...) (où X est de type Int, Long, etc). Lorsque tous les usages sont de cette forme, il n'est jamais possible de partager accidentellement un ThreadLocalRandom sur plusieurs threads.
Cette classe fournit également une génération aléatoire limitée supplémentaire couramment utilisée méthode.
Java dispose d'une classe appelée java.util.Random ce qui peut générer des nombres aléatoires. Si vous voulez que quelque chose se produise avec la probabilité 1/25, générez simplement un nombre aléatoire entre 1 et 25 (ou 0 et 24 inclus) et vérifiez si ce nombre est égal à 1.
if(new java.util.Random().nextInt(25)==0){
//Do something.
}
Peut-être que vous pouvez implémenter ceci en générant des nombres aléatoires.
Random rn = new Random();
double d = rn.nextDouble(); // random value in range 0.0 - 1.0
if(d<=0.04){
doSomeThing();
}