Lire fichier contenant de l'unicode

Version imprimable

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

Code:

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

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:

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:

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

le résultat est correcte

07/09/2011, 18h26
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 ?
07/09/2011, 23h11
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.
08/09/2011, 09h17
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

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:

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

08/09/2011, 11h56
tchize_

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

Code:

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 :mouarf:
13/09/2011, 09h51
megaloplex

Merci pour vos conseils :)