Discussion :

[megaloplex]

Bonjour
j'ai un fichier qui est en UTF-8 et contenant des données unicode

Code :

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

\u65e5\u672c\u8a9e\u6587\u5b57\u5217

j'ai réalisé deux méthodes l'une permettant de lire le contenu du fichier et l'autre l'enregistrer dans un autre fichier

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
 
static String readInput(String file) {
 
		StringBuffer buffer = new StringBuffer();
		try {
			FileInputStream fis = new FileInputStream(file);
			InputStreamReader isr = new InputStreamReader(fis, "UTF8");
			Reader in = new BufferedReader(isr);
			int ch;
			while ((ch = in.read()) > -1) {
				buffer.append((char) ch);
			}
			in.close();
			return buffer.toString();
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}

Ecriture

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
static void writeOutput(String str, String file) {
 
		try {
			FileOutputStream fos = new FileOutputStream(file);
			Writer out = new OutputStreamWriter(fos, "UTF8");
			out.write(str);
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

si le texte unicode est affiché au moyen d'un simple

Code x :

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

1
2
3
4
System.out.println("\u65e5\u672c\u8a9e\u6587\u5b57\u5217");
Resultat :
日本語文字列

le résultat est correcte

[thelvin]

Ok, merci pour les infos... Quelques conseils :

Il vaut mieux utiliser StringBuilder plutôt que StringBuffer.
Et il vaut mieux lire des tableaux de char[] plutôt qu'un char à la fois.

Sinon, tu avais une question ?

[tchize_]

Pour info, les séquence d'échappement \u ne concernent QUE le code source java, c'est une facilité d'écriture du code source qui t'es offerte par le compilateur et rien d'autre. Ce n'est absolument pas interprété dans le fichier lu par les Reader et autres classes java, et ça n'aurait aucun sens d'ailleurs. Si tu veux écrire "日本語文字列" dans ton fichier UTF-8 source, tu dois l'écrire tel quel, et pas autrement.

[megaloplex]

Merci tchize_ pour ces indications, car j'ai un fichier contenant du texte avec de l'unicode, ce fichier est issu de dbpedia version sémantique de wikipedia, il y a bien un moyen de lecture et conversion d'unicode contenu dans un fichier ref

[adiGuba]

Salut,



D'autres remarques sur le code :

• Il est préférable d'utiliser des try/finally pour libérer les ressources dans tous les cas. Ou mieux un try-with-resource avec Java 7 !
• Le return null c'est pas top... Au lieu de traiter les exceptions tu va devoir gérer les valeurs null :/ Il vaut mieux laisser l'exception remonter.

Quand à ton problème, il suffit de rechercher les chaines \uXXXX dans le texte lu, et de les remplacer par leurs valeurs (sachant que XXXX correspond à la valeur hexa en unicode).


Ca se fait assez facilement avec les regexp

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
	static String readInput(String file) throws IOException {
		StringBuilder buffer = new StringBuilder();
 
		// On lit le fichier :
		Charset utf8 = Charset.forName("UTF8");
		InputStreamReader isr = new InputStreamReader(new FileInputStream(file), utf8);
		try {
			char[] cbuf = new char[8192];
			int len;
			while ((len = isr.read(cbuf)) >= 0)
				buffer.append(cbuf, 0, len);
		} finally {
			isr.close();
		}
 
 
		// On crée un Pattern permettant de rechercher les \\uxxxx
		Pattern pattern = Pattern.compile("\\\\" + // Le caractère '\'
				"u" + // Le caractère 'u'
				"([0-9a-fA-F]{4})" // Les caractères 0-9 a-f ou A-F, 4 fois
		);
		// On l'associe avec notre StringBuilder :
		Matcher matcher = pattern.matcher(buffer);
		// Comme on va modifier le StringBuilder en même temps
		// on doit conserver l'index du début de la recherche :
		int start = 0;
		// Pour chaque élément trouvé :
		while (matcher.find(start)) {
			// On récupère les index de début et de fin :
			start = matcher.start();
			int end = matcher.end();
 
			// On récupère la valeur du codePoint (en hexa) :
			int codePoint = Integer.parseInt(matcher.group(1), 16);
 
			// On supprime la partie correspondante du StringBuilder :
			buffer.delete(start, end);
 
			// Et on insert cela à la position actuelle :
			buffer.insert(start, Character.toChars(codePoint));
		}
 
 
		return buffer.toString();
	}

a++

[tchize_]

je rajouterais au message d'adiguba, si le texte est grand, préférer déjà ce code un peu plus performant :

Code :

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

			buffer.replace(start, end,new String(Character.toChars(codePoint)));

Ca évite à StringBuilder de recopier deux fois son tableau. Bien sur l'idéal est un remplacement à la volée pendant la lecture, mais c'est plus long à coder