Écrire un fichier en UTF-8 en utilisant FileWriter (Java)?

Question

J'ai le code suivant cependant, je veux qu'il écrive comme un fichier UTF-8 pour gérer les caractères étrangers. Y a-t-il un moyen de faire cela, est-il nécessaire d'avoir un paramètre?

J'apprécierais vraiment votre aide avec ceci. Merci.

 try {
  BufferedReader reader = new BufferedReader(new FileReader("C:/Users/Jess/My Documents/actresses.list"));
  writer = new BufferedWriter(new FileWriter("C:/Users/Jess/My Documents/actressesFormatted.csv"));
  while( (line = reader.readLine()) != null) {
    //If the line starts with a tab then we just want to add a movie
    //using the current actor's name.
    if(line.length() == 0)
      continue;
    else if(line.charAt(0) == '\t') {
      readMovieLine2(0, line, surname.toString(), forename.toString());
    } //Else we've reached a new actor
    else {
      readActorName(line);
    }
  }
} catch (IOException e) {
  e.printStackTrace();
}
 

Answer 1

Coffre-Fort De L'Encodage Des Constructeurs

Prise en Java pour bien vous informer des erreurs de codage est délicate. Vous devez utiliser le niveau le plus détaillé et, hélas, le moins utilisé des quatre suppléants contructors pour chacun d' InputStreamReader et OutputStreamWriter de recevoir un bon d'exception sur un problème d'encodage.

Pour les e/S de fichier, assurez-vous de toujours utiliser le second argument à la fois OutputStreamWriter et InputStreamReader de la fantaisie de l'encodeur argument:

  Charset.forName("UTF-8").newEncoder()

Il y a d'autres même amateur de possibilités, mais aucun des trois plus simple des possibilités de travail pour l'exception de la remise. Ces faire:

 OutputStreamWriter char_output = new OutputStreamWriter(
     new FileOutputStream("some_output.utf8"),
     Charset.forName("UTF-8").newEncoder() 
 );

 InputStreamReader char_input = new InputStreamReader(
     new FileInputStream("some_input.utf8"),
     Charset.forName("UTF-8").newDecoder() 
 );

Comme pour l'exécution avec

 $ java -Dfile.encoding=utf8 SomeTrulyRemarkablyLongcLassNameGoeShere

Le problème est que cela ne va pas utiliser la totalité de l'encodeur argument de la forme de flux de caractères, et si vous ratez plus les problèmes de codage.

Plus Exemple

Voici un exemple plus, celui-ci la gestion d'un processus au lieu d'un fichier, où nous faisons la promotion de deux octets d'entrée des flux et une sortie de flux d'octets, tous en UTF-8 flux de caractères avec plein traitement d'exception:

 // this runs a perl script with UTF-8 STD{IN,OUT,ERR} streams
 Process
 slave_process = Runtime.getRuntime().exec("perl -CS script args");

 // fetch his stdin byte stream...
 OutputStream
 __bytes_into_his_stdin  = slave_process.getOutputStream();

 // and make a character stream with exceptions on encoding errors
 OutputStreamWriter
   chars_into_his_stdin  = new OutputStreamWriter(
                             __bytes_into_his_stdin,
         /* DO NOT OMIT! */  Charset.forName("UTF-8").newEncoder()
                         );

 // fetch his stdout byte stream...
 InputStream
 __bytes_from_his_stdout = slave_process.getInputStream();

 // and make a character stream with exceptions on encoding errors
 InputStreamReader
   chars_from_his_stdout = new InputStreamReader(
                             __bytes_from_his_stdout,
         /* DO NOT OMIT! */  Charset.forName("UTF-8").newDecoder()
                         );

// fetch his stderr byte stream...
 InputStream
 __bytes_from_his_stderr = slave_process.getErrorStream();

 // and make a character stream with exceptions on encoding errors
 InputStreamReader
   chars_from_his_stderr = new InputStreamReader(
                             __bytes_from_his_stderr,
         /* DO NOT OMIT! */  Charset.forName("UTF-8").newDecoder()
                         );

Maintenant vous avez trois flux de caractères que tous raise exception sur les erreurs d'encodage, respectivement appelés chars_into_his_stdin, chars_from_his_stdout, et chars_from_his_stderr.

C'est seulement un peu plus compliqué que ce que vous avez besoin pour votre problème, dont la solution que j'ai donné dans la première moitié de cette réponse. Le point clé est que c'est la seule façon de détecter les erreurs de codage.

Juste ne me lancez pas sur PrintStreams de manger des exceptions.

Answer 2

Vous devez utiliser l' OutputStreamWriter classe comme l'écrivain paramètre BufferedWriter. Il accepte un codage. Examen de la documentation javadoc pour elle.

Un peu comme ceci:

BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
    new FileOutputStream("jedis.txt"), "UTF-8"
));

Ou vous pouvez définir le système actuel d'encodage avec le système de propriété file.encoding de l'UTF-8.

java -Dfile.encoding=UTF-8 com.jediacademy.Runner arg1 arg2 ...

Vous pouvez également la définir comme un système de propriété au moment de l'exécution avec System.setProperty(...) si vous avez uniquement besoin de ce fichier spécifique, mais dans un cas comme cela, je pense que je préférerais l' OutputStreamWriter.

Par le réglage du système de la propriété vous pouvez utiliser FileWriter et s'attendent à ce que l'utilisation de l'UTF-8 comme encodage par défaut de vos fichiers. Dans ce cas, pour tous les fichiers que vous lire et à écrire.

MODIFIER

Comme suggéré dans les commentaires ci-dessous par tchrist, si vous avez l'intention de détecter les erreurs d'encodage de votre fichier, vous seriez obligé d'utiliser l' OutputStreamWriter d'approche et d'utiliser le constructeur qui reçoit un jeu de caractères de l'encodeur.

Un peu comme

CharsetEncoder encoder = Charset.forName("UTF-8").newEncoder();
encoder.onMalformedInput(CodingErrorAction.REPORT);
encoder.onUnmappableCharacter(CodingErrorAction.REPORT);
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("jedis.txt"),encoder));

Vous pouvez choisir entre les actions IGNORE | REPLACE | REPORT

Aussi, cette question a déjà été répondu ici.