Discussion :

[SuperChafouin]

Bonjour à tous

Voilà je souhaiterais disposer d'une méthode qui supprime les accents dans une chaîne. Par exemple,

Code :

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

J'ai été à la pêche

devient

Code :

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

J'ai ete a la peche

1) existe t'il une API qui fasse cela de façon simple ?
2) s'il n'y a pas d'API, comment coderiez vous-cela ? avec un switch/case à rallonge avec tous les cas possibles ? genre :

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
public static char convert(char c) {		
	if (c >= 97 && c <= 122) {
		return c;
	} else if (c >= 65 && c <= 90) {
		return c;
	} else if (c >= 43 && c <= 57) {
		return c;
	} else if (c == 32 || c == 39 || c == 40 || c == 41 || c == 58 || c == 63) {
		return c;
	} else {
		switch (c) {
		case 'À' : case 'Á' : case 'Â' :
			return 'A';			
		case 'Ç' :
			return 'C';
		case 'È' : case 'É' : case 'Ê' : case 'Ë' :
			return 'E';
		case 'â' : case 'à' : case 'ä' :
			return 'a';
		case 'ç' :
			return 'c';
		case 'ê' : case 'è' : case 'é' : case 'ë' :
			return 'e';
		case 'ï' : case 'î' :
			return 'i';
		case 'ò' : case 'ó' : case 'ô' : case 'ö' : 
			return 'o';
		case 'û' : case 'ü' : case 'ù' : 
			return 'u';
		default : 
			return '?';
		}
	}
}

Merci d'avance pour votre aide !

[divxdede]

Bonjour,

Tu as plusieurs solutions à ce problème.
Aucune n'est parfaite.

1. Utiliser sun.text.Normalizer

Code :

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

1
2
3
static public String sansAccents(String s) {
		return Normalizer.normalize(s, Normalizer.DECOMP, 0).replaceAll("[^\\p{ASCII}]", "");
	}

Inconvénient: les classes de sun sont "non standard/portables" et donc a NE PAS UTILISER. Ces classes sont normalement à usage interne de la jvm

2. Utiliser ICU4J

Code :

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

1
2
Transliterator accentsconverter = Transliterator.getInstance("NFD; [:M:] Remove; NFC; ");
return accentsconverter.transliterate(yourString);

Inconvénient: Il faut un bibliothéque externe de plusieurs méga (3mo)

3. Ecrire ou utiliser une classe prévue à cet effet

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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
package org.divxdede.util.text;
 
/** Classe complementaire du J2SDK sur la manipulation de chaines de caractéres 
 *  Permet nottament de supprimer les accents d'une chaine de caractères
 *
 * @author André Sébastien
 **/
 public class StringOperation
 {
     /** Mise en minuscule **/
     public static final int LOWER_CASE             = 4;
 
     /** Mise en majuscule **/
     public static final int UPPER_CASE             = 8;
 
     /** Remplacement des caractères accentués par leur versions sans accents **/
     public static final int WITHOUT_ACCENTS        = 16;
 
     /** Index du 1er caractere accentué **/
     private static final int MIN = 192;
 
     /** Index du dernier caractere accentué **/
     private static final int MAX = 383;
 
     /** Vecteur de correspondance entre accent / sans accent **/
     private static final char[] map = initMap();
 
     /** Initialisation du tableau de correspondance entre les caractéres accentués et leur homologues non accentués **/
     private static char[] initMap()
     {  char[] result = new char[ MAX - MIN + 1 ];
        char   car    = ' ';
 
        car = 'A';
        result[00] = car;            /* '\u00C0'   À   alt-0192  */  
        result[01] = car;            /* '\u00C1'   Á   alt-0193  */
        result[02] = car;            /* '\u00C2'   Â   alt-0194  */
        result[03] = car;            /* '\u00C3'   Ã   alt-0195  */
        result[04] = car;            /* '\u00C4'   Ä   alt-0196  */
        result[05] = car;            /* '\u00C5'   Å   alt-0197  */
        car = ' ';
        result[06] = car;            /* '\u00C6'   Æ   alt-0198             ********* BI-CARACTERE ******** */
        car = 'C';
        result[07] = car;            /* '\u00C7'   Ç   alt-0199  */
        car = 'E';
        result[8]  = car;            /* '\u00C8'   È   alt-0200  */
        result[9]  = car;            /* '\u00C9'   É   alt-0201  */
        result[10] = car;            /* '\u00CA'   Ê   alt-0202  */
        result[11] = car;            /* '\u00CB'   Ë   alt-0203  */
        car = 'I';
        result[12] = car;            /* '\u00CC'   Ì   alt-0204  */
        result[13] = car;            /* '\u00CD'   Í   alt-0205  */
        result[14] = car;            /* '\u00CE'   Î   alt-0206  */
        result[15] = car;            /* '\u00CF'   Ï   alt-0207  */
        car = 'D';
        result[16] = car;            /* '\u00D0'   Ð   alt-0208  */
        car = 'N';
        result[17] = car;            /* '\u00D1'   Ñ   alt-0209  */
        car = 'O';
        result[18] = car;            /* '\u00D2'   Ò   alt-0210  */
        result[19] = car;            /* '\u00D3'   Ó   alt-0211  */
        result[20] = car;            /* '\u00D4'   Ô   alt-0212  */
        result[21] = car;            /* '\u00D5'   Õ   alt-0213  */
        result[22] = car;            /* '\u00D6'   Ö   alt-0214  */
        car = '*';
        result[23] = car;            /* '\u00D7'   ×   alt-0215            ***** NON ALPHA **** */
        car = '0';
        result[24] = car;            /* '\u00D8'   Ø   alt-0216  */
        car = 'U';
        result[25] = car;            /* '\u00D9'   Ù   alt-0217  */
        result[26] = car;            /* '\u00DA'   Ú   alt-0218  */
        result[27] = car;            /* '\u00DB'   Û   alt-0219  */
        result[28] = car;            /* '\u00DC'   Ü   alt-0220  */
        car = 'Y';
        result[29] = car;            /* '\u00DD'   Ý   alt-0221  */
        car = ' ';
        result[30] = car;            /* '\u00DE'   Þ   alt-0222            ***** NON ALPHA **** */
        car = 'B';
        result[31] = car;            /* '\u00DF'   ß   alt-0223            ***** NON ALPHA **** */
        car = 'a';
        result[32] = car;            /* '\u00E0'   à   alt-0224  */
        result[33] = car;            /* '\u00E1'   á   alt-0225  */
        result[34] = car;            /* '\u00E2'   â   alt-0226  */
        result[35] = car;            /* '\u00E3'   ã   alt-0227  */
        result[36] = car;            /* '\u00E4'   ä   alt-0228  */
        result[37] = car;            /* '\u00E5'   å   alt-0229  */
        car = ' ';
        result[38] = car;            /* '\u00E6'   æ   alt-0230            ********* BI-CARACTERE ******** */
        car = 'c';
        result[39] = car;            /* '\u00E7'   ç   alt-0231  */
        car = 'e';
        result[40] = car;            /* '\u00E8'   è   alt-0232  */
        result[41] = car;            /* '\u00E9'   é   alt-0233  */
        result[42] = car;            /* '\u00EA'   ê   alt-0234  */
        result[43] = car;            /* '\u00EB'   ë   alt-0235  */
        car = 'i';
        result[44] = car;            /* '\u00EC'   ì   alt-0236  */
        result[45] = car;            /* '\u00ED'   í   alt-0237  */
        result[46] = car;            /* '\u00EE'   î   alt-0238  */
        result[47] = car;            /* '\u00EF'   ï   alt-0239  */
        car = 'd';
        result[48] = car;            /* '\u00F0'   ð   alt-0240  */
        car = 'n';
        result[49] = car;            /* '\u00F1'   ñ   alt-0241  */
        car = 'o';
        result[50] = car;            /* '\u00F2'   ò   alt-0242  */
        result[51] = car;            /* '\u00F3'   ó   alt-0243  */
        result[52] = car;            /* '\u00F4'   ô   alt-0244  */
        result[53] = car;            /* '\u00F5'   õ   alt-0245  */
        result[54] = car;            /* '\u00F6'   ö   alt-0246  */
        car = '/';
        result[55] = car;            /* '\u00F7'   ÷   alt-0247            ***** NON ALPHA **** */
        car = '0';
        result[56] = car;            /* '\u00F8'   ø   alt-0248            ***** NON ALPHA **** */
        car = 'u';
        result[57] = car;            /* '\u00F9'   ù   alt-0249  */
        result[58] = car;            /* '\u00FA'   ú   alt-0250  */
        result[59] = car;            /* '\u00FB'   û   alt-0251  */
        result[60] = car;            /* '\u00FC'   ü   alt-0252  */
        car = 'y';
        result[61] = car;            /* '\u00FD'   ý   alt-0253  */
        car = ' ';
        result[62] = car;            /* '\u00FE'   þ   alt-0254            ***** NON ALPHA **** */
        car = 'y';
        result[63] = car;            /* '\u00FF'   ÿ   alt-0255  */
 
        result[64] = 'A';            /* '\u0100'   ?             */
        result[65] = 'a';            /* '\u0101'   ?             */
        result[66] = 'A';            /* '\u0102'   ?             */
        result[67] = 'a';            /* '\u0103'   ?             */
        result[68] = 'A';            /* '\u0104'   ?             */
        result[69] = 'a';            /* '\u0105'   ?             */
 
        result[70] = 'C';            /* '\u0106'   ?             */
        result[71] = 'c';            /* '\u0107'   ?             */
        result[72] = 'C';            /* '\u0108'   ?             */
        result[73] = 'c';            /* '\u0109'   ?             */
        result[74] = 'C';            /* '\u010A'   ?             */
        result[75] = 'c';            /* '\u010B'   ?             */
        result[76] = 'C';            /* '\u010C'   ?             */
        result[77] = 'c';            /* '\u010D'   ?             */
 
        result[78] = 'D';            /* '\u010e'   ?             */
        result[79] = 'd';            /* '\u010f'   ?             */
        result[80] = 'D';            /* '\u0110'   ?             */
        result[81] = 'd';            /* '\u0111'   ?             */
 
        result[82] = 'E';            /* '\u0112'   ?             */
        result[83] = 'e';            /* '\u0113'   ?             */
        result[84] = 'E';            /* '\u0114'   ?             */
        result[85] = 'e';            /* '\u0115'   ?             */
        result[86] = 'E';            /* '\u0116'   ?             */
        result[87] = 'e';            /* '\u0117'   ?             */
        result[88] = 'E';            /* '\u0118'   ?             */
        result[89] = 'e';            /* '\u0119'   ?             */
        result[90] = 'E';            /* '\u011A'   ?             */
        result[91] = 'e';            /* '\u011B'   ?             */
 
        result[92] = 'G';            /* '\u011C'   ?             */
        result[93] = 'g';            /* '\u011D'   ?             */
        result[94] = 'G';            /* '\u011E'   ?             */
        result[95] = 'g';            /* '\u011F'   ?             */
        result[96] = 'G';            /* '\u0120'   ?             */
        result[97] = 'g';            /* '\u0121'   ?             */
        result[98] = 'G';            /* '\u0122'   ?             */
        result[99] = 'g';            /* '\u0123'   ?             */
 
        result[100] = 'H';            /* '\u0124'   ?             */
        result[101] = 'h';            /* '\u0125'   ?             */
        result[102] = 'H';            /* '\u0126'   ?             */
        result[103] = 'h';            /* '\u0127'   ?             */
 
        result[104] = 'I';            /* '\u0128'   ?             */
        result[105] = 'i';            /* '\u0129'   ?             */
        result[106] = 'I';            /* '\u012A'   ?             */
        result[107] = 'i';            /* '\u012B'   ?             */
        result[108] = 'I';            /* '\u012C'   ?             */
        result[109] = 'i';            /* '\u012D'   ?             */
        result[110] = 'I';            /* '\u012E'   ?             */
        result[111] = 'i';            /* '\u012F'   ?             */
        result[112] = 'I';            /* '\u0130'   ?             */
        result[113] = 'i';            /* '\u0131'   ?             */
 
        result[114] = ' ';            /* '\u0132'   ?                 ********* BI-CARACTERE ******** */
        result[115] = ' ';            /* '\u0133'   ?                 ********* BI-CARACTERE ******** */
        result[116] = 'J';            /* '\u0134'   ?             */
        result[117] = 'j';            /* '\u0135'   ?             */
 
        result[118] = 'K';            /* '\u0136'   ?             */
        result[119] = 'k';            /* '\u0137'   ?             */
        result[120] = 'k';            /* '\u0138'   ?             */
 
        result[121] = 'L';            /* '\u0139'   ?             */
        result[122] = 'l';            /* '\u013A'   ?             */
        result[123] = 'L';            /* '\u013B'   ?             */
        result[124] = 'l';            /* '\u013C'   ?             */
        result[125] = 'L';            /* '\u013D'   ?             */
        result[126] = 'l';            /* '\u013E'   ?             */
        result[127] = 'L';            /* '\u013F'   ?             */
        result[128] = 'l';            /* '\u0140'   ?             */
        result[129] = 'L';            /* '\u0141'   ?             */
        result[130] = 'l';            /* '\u0142'   ?             */
 
        result[131] = 'N';            /* '\u0143'   ?             */
        result[132] = 'n';            /* '\u0144'   ?             */
        result[133] = 'N';            /* '\u0145'   ?             */
        result[134] = 'n';            /* '\u0146'   ?             */
        result[135] = 'N';            /* '\u0147'   ?             */
        result[136] = 'n';            /* '\u0148'   ?             */
        result[137] = 'n';            /* '\u0149'   ?             */
        result[138] = 'N';            /* '\u014A'   ?             */
        result[139] = 'n';            /* '\u014B'   ?             */
 
        result[140] = 'O';            /* '\u014C'   ?             */
        result[141] = 'o';            /* '\u014D'   ?             */
        result[142] = 'O';            /* '\u014E'   ?             */
        result[143] = 'o';            /* '\u014F'   ?             */
        result[144] = 'O';            /* '\u0150'   ?             */
        result[145] = 'o';            /* '\u0151'   ?             */
        result[146] = ' ';            /* '\u0152'   Π                ********* BI-CARACTERE ******** */
        result[147] = ' ';            /* '\u0153'   œ                 ********* BI-CARACTERE ******** */
 
        result[148] = 'R';            /* '\u0154'   ?             */ /* --> non testé dans test JUnit */
        result[149] = 'r';            /* '\u0155'   ?             */
        result[150] = 'R';            /* '\u0156'   ?             */
        result[151] = 'r';            /* '\u0157'   ?             */
        result[152] = 'R';            /* '\u0158'   ?             */
        result[153] = 'r';            /* '\u0159'   ?             */
 
        result[154] = 'S';            /* '\u015A'   ?             */
        result[155] = 's';            /* '\u015B'   ?             */
        result[156] = 'S';            /* '\u015C'   ?             */
        result[157] = 's';            /* '\u015D'   ?             */
        result[158] = 'S';            /* '\u015E'   ?             */
        result[159] = 's';            /* '\u015F'   ?             */
        result[160] = 'S';            /* '\u0160'   Š             */
        result[161] = 's';            /* '\u0161'   š             */
 
        result[162] = 'T';            /* '\u0162'   ?             */
        result[163] = 't';            /* '\u0163'   ?             */
        result[164] = 'T';            /* '\u0164'   ?             */
        result[165] = 't';            /* '\u0165'   ?             */
        result[166] = 'T';            /* '\u0166'   ?             */
        result[167] = 't';            /* '\u0167'   ?             */
 
        result[168] = 'U';            /* '\u0168'   ?             */
        result[169] = 'u';            /* '\u0169'   ?             */
        result[170] = 'U';            /* '\u016A'   ?             */
        result[171] = 'u';            /* '\u016B'   ?             */
        result[172] = 'U';            /* '\u016C'   ?             */
        result[173] = 'u';            /* '\u016D'   ?             */
        result[174] = 'U';            /* '\u016E'   ?             */
        result[175] = 'u';            /* '\u016F'   ?             */
        result[176] = 'U';            /* '\u0170'   ?             */
        result[177] = 'u';            /* '\u0171'   ?             */
        result[178] = 'U';            /* '\u0172'   ?             */
        result[179] = 'u';            /* '\u0173'   ?             */
 
        result[180] = 'W';            /* '\u0174'   ?             */
        result[181] = 'w';            /* '\u0175'   ?             */
 
        result[182] = 'Y';            /* '\u0176'   ?             */
        result[183] = 'y';            /* '\u0177'   ?             */
        result[184] = 'Y';            /* '\u0178'   Ÿ             */
 
        result[185] = 'Z';            /* '\u0179'   ?             */
        result[186] = 'z';            /* '\u017A'   ?             */
        result[187] = 'Z';            /* '\u017B'   ?             */
        result[188] = 'z';            /* '\u017C'   ?             */
        result[189] = 'Z';            /* '\u017D'   Ž             */
        result[190] = 'z';            /* '\u017E'   ž             */
 
        result[191] = 'f';            /* '\u017F'   ?             */
 
        return result;
     }
 
     /** Transforme une chaine de caractères selon differents critères (paramètre mode),
      *  @param chaine Chaine sur laquelle on veut effectuer une transformation
      *  @param mode Mode de transformation, plusieurs mode sont accessibles, ceux-ci peuvent être combiné
      *              - LOWER_CASE             : Mise en minuscule
      *              - UPPER_CASE             : Mise en majuscule
      *              - WITHOUT_ACCENTS        : Remplace les caractères accentués par leur version sans accent
      *                                         La combinaision de mode se fait de la sorte LOWER_CASE | WITHOUT_ACCENTS
      * @return Chain transformée
      **/
    public static java.lang.String transform(java.lang.String chaine , int mode)
    {
        if( mode == UPPER_CASE ) return chaine.toUpperCase();
        if( mode == LOWER_CASE ) return chaine.toLowerCase();
 
        int firstReplacement = scan( chaine, mode );
 
        if( firstReplacement == -1 ) return chaine;
 
        char[] result = chaine.toCharArray();
        int    offset = firstReplacement;
 
        boolean toUpper         = (mode & UPPER_CASE) > 0;
        boolean toLower         = (mode & LOWER_CASE) > 0;
        boolean withoutAccents  = (mode & WITHOUT_ACCENTS) > 0;
 
        for(int bcl = firstReplacement ; bcl < chaine.length() ; bcl++ )
        {
            char    c     = result[bcl];
            int     type  = Character.getType(c);    
 
            /** Remplacement
             */
            char    r     = c;
 
            /** isLetter()
             */
            if(    type == Character.UPPERCASE_LETTER || type == Character.LOWERCASE_LETTER 
                || type == Character.TITLECASE_LETTER || type == Character.MODIFIER_LETTER 
                || type == Character.OTHER_LETTER ) // || type == Character.OTHER_PUNCTUATION )
            {
                if( toUpper && (type == Character.LOWERCASE_LETTER || type == Character.OTHER_PUNCTUATION) )
                {   r = Character.toUpperCase(c); }
                else if( toLower && (type == Character.UPPERCASE_LETTER || type == Character.OTHER_PUNCTUATION ) )
                    r = Character.toLowerCase(c);
 
                if( withoutAccents && r >= MIN && r <= MAX &&
                        ( r != 198 && r != 230 && r != 306 && r != 307 && r != 339 && r != 340 ) )
                {
                   r = map[ (int)r - MIN ];
                }
            }
 
            result[offset] = r;
            offset++;
        }
 
        String res = new String(result);
        return new String(result,0,offset);
    }
 
    /** Donne l'index du 1er caractère donnant lieu a une transformation selon le mode donné
     *  @param chaine Chaine à tester
     *  @param mode Mode pilotant la future transformation de la chaine
     *  @return index du 1er caractère à transformer, -1 si aucun caractère n'est a transformer
     */
    private static int scan(java.lang.String chaine , int mode)
    {
        /**
            ALPHA_NUM              
            WITHOUT_SPECIALS_CHARS 
            LOWER_CASE             
            UPPER_CASE             
            WITHOUT_ACCENTS        
         */
        int computedMode = 0;
        for(int bcl = 0 ; bcl < chaine.length() ; bcl++ )
        {
            char c     = chaine.charAt(bcl);
            int  type  = Character.getType(c);    
 
            /** isLetter()
             */
            if(    type == Character.UPPERCASE_LETTER || type == Character.LOWERCASE_LETTER 
                || type == Character.TITLECASE_LETTER || type == Character.MODIFIER_LETTER 
                || type == Character.OTHER_LETTER ) // || type == Character.OTHER_PUNCTUATION )
            {
                if( type == Character.LOWERCASE_LETTER )       computedMode = computedMode | UPPER_CASE;
                else if( type == Character.UPPERCASE_LETTER )  computedMode = computedMode | LOWER_CASE;
 
                if( c >= MIN && c <= MAX )
                {   computedMode = computedMode | WITHOUT_ACCENTS; }
            }
 
            if( ( computedMode & mode ) > 0 ) 
                return bcl;
        }
 
        return -1;
    }
 
 
    /** 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 java.lang.String sansAccents(java.lang.String chaine)
    {  return transform(chaine, WITHOUT_ACCENTS ); }
}

Inconvénient: Ecrit à la main, n'est sans doute pas aussi générale que le serait une API comme ICU4J Cependant, le fait d'être écrite uniquement pour cette tâche (suppression des accents) permet d'être relativement efficace.

[adiGuba]

Salut,

Inconvénient: les classes de sun sont "non standard/portables" et donc a NE PAS UTILISER. Ces classes sont normalement à usage interne de la jvm

Cette classe a été intégré en standard dans Java 6 (sous une forme légèrement différente) : http://javasearch.developpez.com/j2s...ormalizer.html

A noter également que tu peux utiliser le pattern "[\u0300-\u036F]" à la place de "[^\\p{ASCII}]" qui supprimera seulement les accents et assimilés mais pas les autres caractères non ascii (bon cela dépend également de ce que tu veux faire exactement )

Exemple Java 6 :

Code :

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

1
2
3
	public static String removeAccent(String source) {
		return Normalizer.normalize(source, Normalizer.Form.NFD).replaceAll("[\u0300-\u036F]", "");
	}

Pour l'explication :

• Normalizer.normalize(source, Normalizer.Form.NFD) renvoi une chaine unicode décomposé. C'est à dire que les caractères accentué seront décomposé en deux caractères (par exemple "à" se transformera en "a`").
• Le replaceAll("[\u0300-\u036F]", "") supprimera tous les caractères unicode allant de u0300 à u036F, c'est à dire la plage de code des diacritiques (les accents qu'on a décomposé ci dessus donc).

a++

[divxdede]

Effectivement, n'ayant pas encore franchit le cap de Java 6, cette classe m'était inconnue... Merci
Cependant en terme de performance, ca me semble assez lourd (dans le cas de transformation de masse) quand bien même le pattern serait compilé une fois pour toute.

[SuperChafouin]

Merci à tous les 2 pour vos réponses claires et précises !

Comme je suis en java 1.4 et que je dois effectuer d'autres traitements spécifiques sur les caractères, je pense que vais opter pour une approche "à la main"
(en plus de convertir les accents, je ne dois laisser passer qu'une certaine plage de caractères, cad remplacer les caractères "exotiques" du genre µ,¤,€,etc. par le caractère "?")