String et méthode

Version imprimable

09/03/2015, 22h52
salimoush

String et méthode

Bonjour,

J'essaie en vain d'écrire une méthode qui retournerait ces valeurs :
— true : si la chaîne contient uniquement des caractères dans l’intervalle [cMin, cMax]
— false : si la chaîne inclus au moins un caractère qui n’est pas dans l’intervalle [cMin, cMax]

En fait, je veux vérifier que ma chaîne de caractère ne contient que des lettres de l'alphabet en utilisant seulement les méthodes suivantes: charAt() et length().

Auriez-vous une solution?

Merci!!!
10/03/2015, 00h02
joel.drigo

Salut,

Si cMIn et cMax sont des caractères (char), il suffit de comparer : si cMin<=c && c<=cMax alors c appartient à l'intervalle. Et c = string.charAt(i) avec i variant de 0 à string.length-1, tout simplement.
10/03/2015, 02h10
salimoush

Merci!

Que veut dire ton c dans cMin<=c && c<=cMax?
Merci.
10/03/2015, 02h12
salimoush

Oops, je suis vraiment à l'ouest, tu as expliqué comment on obtient c juste après lol.
Ne tiens pas compte de ma précédente demande...

J'ai mal compris ce que tu m'as expliqué. Ca m'affiche n résultats en fonction de n caractères que j'entre...
Je colle ici mon code pour avoir de l'aide svp:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main (String[] args) {
        String chaine;
        char cMin;
        char cMax;
        int longueur;        
        cMin='a';
        cMax='z';
 
        System.out.println("Chaine?");
        chaine=Clavier.lireString();
        for ( int i = 0; i < chaine.length(); i++ ) {
            if ( chaine.charAt( i ) >=cMin && chaine.charAt( i )<=cMax  ) {
                System.out.println("true");
            }else{
                System.out.println("false");
            }
        }
    } // main

Tout est dans la description :

Citation:

Envoyé par salimoush

une méthode qui retournerait ces valeurs :
— true : si la chaîne contient uniquement des caractères dans l’intervalle [cMin, cMax]
— false : si la chaîne inclus au moins un caractère qui n’est pas dans l’intervalle [cMin, cMax]

La fonction est globable : on a soit true soit false, alors qu'afficher true ou false pour chaque caractère, affiche forcément plusieurs fois true ou false. La fonction vaut donc : caractère 0 est dans [cMin, cMax] et caractère 1 est dans [cMin, cMax] et caractère 3 est dans [cMin, cMax] et ... Bien sûr, on ne peut pas faire autant de if qu'il y a de caractères : on va faire ça dans une boucle, et faire que chaque test fait dans chaque itération se cumule pour n'avoir qu'une seule valeur true ou false.
Code:

1 2 3 4 5 6 7 boolean resultat=true; for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); resultat &= (c >= cMin && c <= cMax); // cumule avec &= } System.out.println( resultat );
Ensuite, on peut simplifier. On sait que pour un et, il suffit qu'un seul test soit faux pour que la combinaison et de tous les tests est forcément false (en algère booléenne : a & false est false, donc a & b & false est false, a & b & c & false est false, etc.

Donc il suffit de faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public static boolean containsOnly(String s, char cMin, char cMax) { if ( s.length()==0 ) { // la chaine est vide (ou null), alors il n'y a aucun caractère dans l'intervalle, // mais on ne peut pas dire non plus qu'il y a au moins caractère qui n'est pas dans l'intervalle // il ne faudrait pas appeler cette méthode avec une chaine vide (ou null, mais dans ce cas ça va faire une NullPointerException) // on peut retourner n'importe quoi comme valeur, aucune des deux n'a de sens // on va soulever une exception pour dire qu'on ne devrait pas appeler cette méthode dans ce cas throw new IllegalArgumentException("String is empty"); } else if ( cMin>cMax ) { // l'intervalle est incorrect, on soulève une exception throw new IllegalArgumentException("cMin > cMax"); } else { for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); if (c < cMin || c > cMax) { // le caractère n'est pas dans l'intervalle return false; // alors on a au moins un caractère qui n'est pas dans l'intervalle, donc le résultat est false } } return true; // tous les caractères étaient forcément dans l'intervalle alors le résultat est true } }