Bonjour ,
je commence en Java et j'ai chercher dans le tuto officiel si il expliquai comment choisir un nombre aléatoiremet entre les deux nombres qu'on donne. En php c'est :

<?php
$ma_var = rand(1,9); 
?>

par exemple mais comment faire ca en Java

Je vous remercie d'avance !
Dakaro

Tu peux utiliser :

Math.random(); // qui te donne un nombre entre 0 et 1
Math.random() * 9 //Te donnera un nombre enrte 0 et 9

Avec c'est entre 0 et 9

Math.random() * 9;

Ok merci beaucoup , et comment ece-que je fait pour en choisir un au hasard entre 1 et 9 ?

Edit : et avec le:

int hasard2 = (int) Math.random()* 9;
		System.out.print(hasard2);

Il me donne toujours 0, je refitplusieurs fois ctrl + F11 mais toujours 0

Il faut que tu cast le résultat de l'opération :

int hazard = (int) (Math.random() * 9);
//Comme ça tu cast le résultat
//Sinon tu castais le random, hors 0.xxxxx vaut souvent 0

Ok ,
maintenant ca marche mais le 0 n'est pas exclus ,
maintenant comment faire entre 1 et 9 ?

Allez, cherche un peu...
une petite boucle pourrais faire l'affaire non.

Citation : cysboy

Allez, cherche un peu...
une petite boucle pourrais faire l'affaire non.

int hazard = 0;
while(hazard < 1)
   hazard = (int)(Math.random() * 9);

Je ne suis pas encore arriver au stade des boucles x)
mais je code en php alors je sais ce que ca va donner plus ou moins
et j'aurai dis comme toi !

Merci beaucoup

faut pas oublier de marquez comme résolut

Pourquoi faire un while bête méchant et lourd pour interdire la valeur 0 ?

J'y connais rien en java, mais mathématique un +1 suffit amplement..

C'est vrai...

Utilisez directement la classe random, ça fait plus ... class.

Random rand = new Random();
int n = rand.nextInt(8)+1;

int hazard = (int) (Math.random() * 9);
if(hazard == 0)
{
hazard++;
}

haaa11,
Ton code n'est pas faux, mais ça ne donne pas une chance égale pour tout tes résultats. En effet avec ton code tu as plus de chance d'obtenir 1, vu que 0 donne 1 également ...

Voici le code qui répondrait à la question de base avec des chances égales.

int hazard = ((int)(Math.random() * 8)) + 1;

je rajouterai même que le cast réalisé un troncage des virgules. Ce qui veut dire :

(int) 0.6; // donne 0
(int) 0.2; // donne 0

Pour plus d'égalité des chances, il vaut mieux utiliser la méthode round de la classe Math. Ce qui donnerait :

int hazard = ((int) Math.round((Math.random() * 8))) + 1;

Citation : haaa11

int hazard = (int) (Math.random() * 9);
if(hazard == 0)
{
hazard++;
}

Sauf que là c'est plus vraiment aléatoire, tu as deux fois plus de chance d'avoir un 1 que les autres chiffres.

EDIT : J'avais pas vu la réponse précédente. Mais j'aime assez la solution de QuentinC 2.

Faux, avec round la répartition n'est pas égale... on a deux fois moins de chance d'obtenir les extrêmes.

j'ai dit

Citation : ReiVon

Pour plus d'égalité des chances, [...]

je n'ai pas dit que l'égalité était parfaite.

D'ailleurs je suis curieux de voir l'algorithme de nextInt() de la classe Random sur ce sujet.

Citation

Pour plus d'égalité des chances, [...]

Justement, tu l'amoindris par rapport à si tu avais utilisé Math.floor.

Je m'explique : Admettons que tu veux un nombre compris entre 0 et 9 inclus.
Si tu utilises Math.round pour l'arrondi, tu obtiendras 0 pour un Math.random compris entre 0.0 et 0.05, 1 pour un nombre compris entre 0.05 et 0.15, etc.
Que constatons-nous ? la plage qui donne 0 est deux fois plus petite que celle qui donne 1, que celle qui donne 2, etc. La dernière plage est non seulement hors limite mais elle est aussi tronquée.
Avec Math.floor ou Math.ceil, toutes les plages sont les mêmes.

Pour l'implémentation de la classe Random, je n'en mettrais pas la main au feu mais je suis presque sûr que Math.random utilise nextDouble qui lui-même utilise nextInt sans paramètre suivi d'une division par 2^31. Les générateurs de nombres pseudo-aléatoires travaillent en principe sur des nombres entiers, c'est plus facile.

Oui je comprends QuentinC 2.

Méa culpa de ma part.

Merci pour l'information du nextInt, j'irai me renseigner à ce sujet !

Sinon pour la méthode floor, la borne supérieur aura moins de chance que les autres solutions non ?
On rentre dans des maths, mais bon, c'est la base de l'informatique après tout :D.

Citation

Sinon pour la méthode floor, la borne supérieur aura moins de chance que les autres solutions non ?
On rentre dans des maths, mais bon, c'est la base de l'informatique après tout :D.

Non. La seule chose à savoir c'est que la borne supérieure indiquée ne peut pas sortir.
Quand tu fais : int n = Math.floor(Math.random()*100), le 100 ne peut jamais sortir, tu auras au maximum 99.

En maths, on dirait que l'ensemble des images de la fonction Math.random est un intervalle compris entre 0 inclusif (ouvert) et 1 exclusif (fermé). En bref, on peut avoir un nombre qui tend vers 1 mais qui n'est jamais strictement égal à 1 (très probablement (<math>\(\frac{(2^{31})-1}{2^{31}}\)</math>. C'est la définition de la fonction random, comme nous le dit la javadoc :

Citation

Returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0.

De par cette définition, on est certain à 100% que n*Math.random() < n, et donc, Math.floor(n * Math.random()) < n puisque floor arrondit toujours vers le bas.
Attention, on ne peut pas faire une conclusion similaire avec Math.ceil, car la valeur 0 a une probabilité minime mais non nulle de sortir, et Math.ceil(n)=n si n est entier.

Merci pour ces explications !