Expression reguliere + normalisation string

Version imprimable

19/08/2008, 16h23
xduris

Expression reguliere + normalisation string

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.
19/08/2008, 17h50
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.
19/08/2008, 21h24
adiGuba
Salut,

Citation:

Envoyé par xduris

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

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

Pour supprimer tous les blancs :

Code:

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

Citation:

Envoyé par xduris

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

Citation:

Envoyé par xduris

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

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

Citation:

Envoyé par xduris

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

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

SUPER!!! Merci beaucoup.

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

Code:

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