Contenu d'un String

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.

Regarde par ici :

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

Je pense que ca doit marcher aussi avec le sdk android :)

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:

---

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

entier ou réel entre o et 100.

Inter.valueOf(chaine);

ou

Float.valOf(chaine)

puis de le test de validité

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

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

Code:

---

^[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

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.

Citation:

---

Envoyé par thelvin

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 :mouarf:

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

Citation:

---

Envoyé par tchize_

Sauf si la majorité est bien entre 0 et 100 :mouarf:

---

Peux-tu expliciter un peu stp ?

Je suis aussi preneur de plus d'explications :)

Salut,

Citation:

---

Envoyé par Nico02

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++

Tout à fait AdiGuba :mouarf:

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:

---

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:

---

1 2 3

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

---

Citation:

---

Envoyé par 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:

---

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:

---

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:

---

1 2 3 4 5 6

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

---

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

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

Mais j'aurais tendance à réécrire :

Code:

---

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; } }

---

Citation:

---

Envoyé par Iphelias

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

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.