Discussion :

[katze]

Bonjour,

Je récupère une variable String d'une communication pas très fiable, et j'aurai besoin de vérifier que ce String est bien un chiffre entre 0 et 100, auriez-vous une idée de comment je peu faire ?

Merci d'avance.

[Carhiboux]

Regarde par ici :

http://java.developpez.com/telecharg...-nombre-entier

Je pense que ca doit marcher aussi avec le sdk android

[Nico02]

Il y a plusieurs façon de faire.

Une méthode un peu bourrin consisterai a essayer de le caster en Integer, et dans le cas ou ça réussi, regarder si il est entre 0 et 100

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 
int monInt = -1;
 
try{
  monInt = Integer.valueOf(maString);
}
catch(Exception ex){
  return false;
}
return (monInt > 0 && monInt <= 100);

Sinon tu dois aussi pouvoir le faire avec une regExp

[plawyx]

entier ou réel entre o et 100.

Inter.valueOf(chaine);

ou

Float.valOf(chaine)

puis de le test de validité

[Olrem]

Bonjour,

J'ai effectué le même type de recherche il y a peu (je cherchais le meilleur moment de le faire) et j'étais tombé sur cette discussion :
http://stackoverflow.com/questions/2...nteger-in-java

[Ceddoc]

Tu peux aussi vérifier avec un regex que tu as uniquement des chiffres avec quelque chose du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^[0-9]+

puis vu que tu es sûr qu'il s'agit de chiffres faire un Integer.valueOf() et la vérification donnée par Nico02

[thelvin]

Si c'est une fois par traitement, Integer.valueOf() est acceptable.

Mais quand il faut vérifier plein de nombres, on préfèrera Integer.parseInt().
En effet valueOf() renvoie un Integer, donc un objet. Cet objet est alloué, son constructeur est appelé, et il devra être garbage-collecté ensuite. Tout cela est une mécanique coûteuse.
Alors que parseInt() renvoie simplement un int, un type de base, construit en itérant sur la String.

[tchize_]

En effet valueOf() renvoie un Integer, donc un objet. Cet objet est alloué, son constructeur est appelé, et il devra être garbage-collecté ensuite. Tout cela est une mécanique coûteuse.

Sauf si la majorité est bien entre 0 et 100

[thelvin]

Ah, euh... Ma foi, en effet.
Mais bon, pas dans le cas général.

[plawyx]

Sauf si la majorité est bien entre 0 et 100

Peux-tu expliciter un peu stp ?

[Nico02]

Je suis aussi preneur de plus d'explications

[adiGuba]

Salut,

Je suis aussi preneur de plus d'explications

Je suppose qu'il fait allusion au fait que Integer.valueOf() gère un cache d'objet pour les valeur comprise entre -127 et +127 (si je me souviens bien)...

Mais bon globalement il faut quand même préférer le type primitif au type wrapper lorsque c'est possible...


a++

[tchize_]

Tout à fait AdiGuba

disons que dans le range byte, Integer.valueOf() ne construit pas d'objet, donc la surcharge est beaucoup plus faible (pas de boulot du gc, pas de constructeur, etc), mais quand même,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
créer un int à partir de la String
trouver ce int dans le cache
retourner le Integer correspondant
appeler Integer.intValue() dessus
comparer

ca reste plus lent que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
créer un int à partir de la String
retourner le int
comparer

[MasterMbg]

Il y a plusieurs façon de faire.

Une méthode un peu bourrin consisterai a essayer de le caster en Integer, et dans le cas ou ça réussi, regarder si il est entre 0 et 100

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 
int monInt = -1;
 
try{
  monInt = Integer.valueOf(maString);
}
catch(Exception ex){
  return false;
}
return (monInt > 0 && monInt <= 100);

Salut, la logique n'est pas mal du tout. Si ça ne dérangerait pas, en se basant sur ça je te proposerais cette méthode toute faite

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
public static boolean verifier(String maString){
int monInt = -1;
try{
  monInt = Integer.parseInt(maString);
}
catch(Exception ex){
  return false;
}
return (monInt > 0 && monInt <= 100);
}

Tu peux l'appeler dans une structure conditionnelle comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
if(verifier(valChaine){
//Exécution des instructions relatives à la véracité de l'entier en paramètre
}else{
//.......
}

[Iphelias]

Pour moi la meilleur solution c'est les expressions régulières dans ton cas.

[thelvin]

Pour vérifier si c'est entre 0 et 100 ? Je ne crois pas, non...

Mais j'aurais tendance à réécrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public static boolean verifier(String input){
  try{
    int value = Integer.parseInt(input);
    return value > 0 && value <= 100:
  }
  catch(Exception ex){
    return false;
  }
}

[plawyx]

Pour moi la meilleur solution c'est les expressions régulières dans ton cas.

Après la remarque de tchize_, j'ai fouillé sue le net: il y a plusieurs façons de faire cette transformation String_>entier et le test entre 0 et 100. La regex en fait partie mais n'est pas la plus rapide: en moyenne deux à trois fois plus lente que la plus rapide.

katze parle de communication. Si le débit est assez, voir très important, cet aspect devient important.

La solution regex n'est pas obligatoirement la meilleur

[thelvin]

Ce n'est pas qu'une question de performance. La regex est également peu claire, et prend des décisions arbitraires vis-à-vis des zéro devant.

Si on tient à les refuser ça se discute déjà un peu plus, mais dans le cas général, l'intérêt... C'est d'éviter de programmer par exception, au prix d'une regex imbitable et d'une double vérification. Ça va pas loin.