Discussion :

[xduris]

Bonjour,

J'ai une méthode simple à coder qui prend une string en entrée et qui la renvoie normalisé de la manière suivante:
- Suppression des espaces (ok j'utilise trim())
- Remplacement des caractères accentués par leur équivalent (???)
- Mise en majuscule de la chaine de caractère (ok toUpperCase() qui gère du même coup peut être aussi la règle précédente)
- Suppression des caractères qui n'appartiennent pas à l'expression régulière suivante [0-9A-Z] (???)
- Suppression des caractères en double qui se suivent (AA->A jusqu'à ZZ->Z)
(???)

Merci d'avance pour votre aide.

[baos!]

La méthode replaceAll de la classe String devrait t'aider. Sachant que le caractère ^ permet de mettre des catactères en exception.
Ainsi, tout sauf [0-9A-Z] devrait être la même chose que matcher avec [^0-9A-Z]. Enfin, essai.
Sinon, regarde la classe Pattern de l'API Java, http://java.sun.com/j2se/1.5.0/docs/api/ ; il y a la description des expression régulière utilisée par Java.

[adiGuba]

Salut,

- Suppression des espaces (ok j'utilise trim())

Ce n'est pas clair.

Déjà parles du seulement des espaces (caractère \u0020), ou des blancs (espaces, espaces insécables, tabulations, ...) ?
Ensuite veux-tu uniquement supprimer les espaces/blancs en début et fin de chaîne (ce que fait trim()) ou tout les espaces/blancs de la chaîne.

Pour supprimer tous les espaces :

Code :

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

str = str.replaceAll(" ", "");

Pour supprimer tous les blancs :

Code :

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

str = str.replaceAll("\\s", "");

Mais dans tous les cas cela devient inutile par rapport à ta 4ième règle qui supprimera tout ce qui ne correspond pas à une lettre ou un chiffre...

- Remplacement des caractères accentués par leur équivalent (???)
- Mise en majuscule de la chaine de caractère (ok toUpperCase() qui gère du même coup peut être aussi la règle précédente)

toUpperCase() ne supprime pas les accents (c'est facile à vérifier ).
Pour cela il y a plusieurs solutions (plus ou moins simple, et plus ou moins standard) selon la version de Java que tu utilises. Je te laisse consulter la FAQ : http://java.developpez.com/faq/java/...primmer_accent

Un peu de recherche n'aurait pas fait de mal...

- Suppression des caractères qui n'appartiennent pas à l'expression régulière suivante [0-9A-Z] (???)

Comme l'a indiqué baos, le ^ permet la négation :

Code :

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

str = str.replaceAll("[^0-9A-Z]", "");

- Suppression des caractères en double qui se suivent (AA->A jusqu'à ZZ->Z)

Cela peut se faire assez simplement avec l'expression suivante :

Code :

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

str = str.replaceAll("(.)\\1+", "$1");

Explication :

• (.) : Le point désigne un caractère quelconque, et les parenthèse permettent de définir un groupe.
• \\1+ : Le \\1 désigne un élément identique au groupe numéro 1, c'est à dire le point précédent dans notre cas : bref deux lettres identiques quelconques qui se suivent. Le + indique qu'on peut avoir une ou plusieurs fois le \\1, et donc en tout entre 2 à plusieurs lettres identiques.

Enfin on remplace le tout par $1, qui correspond en fait au groupe 1, donc la lettre qui est répété dans notre cas...

a++

[xduris]

SUPER!!! Merci beaucoup.

J'ai donc résolu mon problème de la manière suivante.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
 
    /** Index du 1er caractere accentué * */
    private static final int MIN = 192;
 
    /** Index du dernier caractere accentué * */
    private static final int MAX = 255;
 
    /** Vecteur de correspondance entre accent / sans accent * */
    private static final Vector<String> MAP_ACCENTUATION = initMap();
 
 
 
   private static String normalisation(String str) {
        String res = null;
        res = sansAccent(str);
        res = res.toUpperCase();
        res = res.replaceAll("[^0-9A-Z]", "");
        res = res.replaceAll("(.)\\1+", "$1");
 
        return str;
 
 
    /**
     * Initialisation du tableau de correspondance entre les caractéres accentués et leur homologues non accentués
     * 
     * @return Vector
     */
    //CHECKSTYLE:OFF Metrique NCSS 
    private static Vector<String> initMap() {
    //CHECKSTYLE:ON
        Vector<String> result = new Vector<String>();
        String car = null;
 
        car = new java.lang.String("A");
        result.add(car); /* '\u00C0' À alt-0192 */
        result.add(car); /* '\u00C1' Á alt-0193 */
        result.add(car); /* '\u00C2' Â alt-0194 */
        result.add(car); /* '\u00C3' Ã alt-0195 */
        result.add(car); /* '\u00C4' Ä alt-0196 */
        result.add(car); /* '\u00C5' Å alt-0197 */
        car = new java.lang.String("AE");
        result.add(car); /* '\u00C6' Æ alt-0198 */
        car = new java.lang.String("C");
        result.add(car); /* '\u00C7' Ç alt-0199 */
        car = new java.lang.String("E");
        result.add(car); /* '\u00C8' È alt-0200 */
        result.add(car); /* '\u00C9' É alt-0201 */
        result.add(car); /* '\u00CA' Ê alt-0202 */
        result.add(car); /* '\u00CB' Ë alt-0203 */
        car = new java.lang.String("I");
        result.add(car); /* '\u00CC' Ì alt-0204 */
        result.add(car); /* '\u00CD' Í alt-0205 */
        result.add(car); /* '\u00CE' Î alt-0206 */
        result.add(car); /* '\u00CF' Ï alt-0207 */
        car = new java.lang.String("D");
        result.add(car); /* '\u00D0' Ð alt-0208 */
        car = new java.lang.String("N");
        result.add(car); /* '\u00D1' Ñ alt-0209 */
        car = new java.lang.String("O");
        result.add(car); /* '\u00D2' Ò alt-0210 */
        result.add(car); /* '\u00D3' Ó alt-0211 */
        result.add(car); /* '\u00D4' Ô alt-0212 */
        result.add(car); /* '\u00D5' Õ alt-0213 */
        result.add(car); /* '\u00D6' Ö alt-0214 */
        car = new java.lang.String("*");
        result.add(car); /* '\u00D7' × alt-0215 */
        car = new java.lang.String("0");
        result.add(car); /* '\u00D8' Ø alt-0216 */
        car = new java.lang.String("U");
        result.add(car); /* '\u00D9' Ù alt-0217 */
        result.add(car); /* '\u00DA' Ú alt-0218 */
        result.add(car); /* '\u00DB' Û alt-0219 */
        result.add(car); /* '\u00DC' Ü alt-0220 */
        car = new java.lang.String("Y");
        result.add(car); /* '\u00DD' Ý alt-0221 */
        car = new java.lang.String("Þ");
        result.add(car); /* '\u00DE' Þ alt-0222 */
        car = new java.lang.String("B");
        result.add(car); /* '\u00DF' ß alt-0223 */
        car = new java.lang.String("a");
        result.add(car); /* '\u00E0' à alt-0224 */
        result.add(car); /* '\u00E1' á alt-0225 */
        result.add(car); /* '\u00E2' â alt-0226 */
        result.add(car); /* '\u00E3' ã alt-0227 */
        result.add(car); /* '\u00E4' ä alt-0228 */
        result.add(car); /* '\u00E5' å alt-0229 */
        car = new java.lang.String("ae");
        result.add(car); /* '\u00E6' æ alt-0230 */
        car = new java.lang.String("c");
        result.add(car); /* '\u00E7' ç alt-0231 */
        car = new java.lang.String("e");
        result.add(car); /* '\u00E8' è alt-0232 */
        result.add(car); /* '\u00E9' é alt-0233 */
        result.add(car); /* '\u00EA' ê alt-0234 */
        result.add(car); /* '\u00EB' ë alt-0235 */
        car = new java.lang.String("i");
        result.add(car); /* '\u00EC' ì alt-0236 */
        result.add(car); /* '\u00ED' í alt-0237 */
        result.add(car); /* '\u00EE' î alt-0238 */
        result.add(car); /* '\u00EF' ï alt-0239 */
        car = new java.lang.String("d");
        result.add(car); /* '\u00F0' ð alt-0240 */
        car = new java.lang.String("n");
        result.add(car); /* '\u00F1' ñ alt-0241 */
        car = new java.lang.String("o");
        result.add(car); /* '\u00F2' ò alt-0242 */
        result.add(car); /* '\u00F3' ó alt-0243 */
        result.add(car); /* '\u00F4' ô alt-0244 */
        result.add(car); /* '\u00F5' õ alt-0245 */
        result.add(car); /* '\u00F6' ö alt-0246 */
        car = new java.lang.String("/");
        result.add(car); /* '\u00F7' ÷ alt-0247 */
        car = new java.lang.String("0");
        result.add(car); /* '\u00F8' ø alt-0248 */
        car = new java.lang.String("u");
        result.add(car); /* '\u00F9' ù alt-0249 */
        result.add(car); /* '\u00FA' ú alt-0250 */
        result.add(car); /* '\u00FB' û alt-0251 */
        result.add(car); /* '\u00FC' ü alt-0252 */
        car = new java.lang.String("y");
        result.add(car); /* '\u00FD' ý alt-0253 */
        car = new java.lang.String("þ");
        result.add(car); /* '\u00FE' þ alt-0254 */
        car = new java.lang.String("y");
        result.add(car); /* '\u00FF' ÿ alt-0255 */
        result.add(car); /* '\u00FF' alt-0255 */
 
        return result;
    }
 
    /**
     * Transforme une chaine pouvant contenir des accents dans une version sans accent
     * 
     * @param chaine
     *        Chaine a convertir sans accent
     * @return Chaine dont les accents ont été supprimé
     */
    public static String sansAccent(java.lang.String chaine) {
        java.lang.StringBuffer result = new StringBuffer(chaine);
 
        for (int bcl = 0; bcl < result.length(); bcl++) {
            int carVal = chaine.charAt(bcl);
            if (carVal >= MIN && carVal <= MAX) { // Remplacement
                java.lang.String newVal = (java.lang.String) MAP_ACCENTUATION.get(carVal - MIN);
                result.replace(bcl, bcl + 1, newVal);
            }
        }
        return result.toString();
    }

Encore merci