E/S java, writng un tableau à un fichier texte

Question

je suis en utilisant le code suivant pour écrire un tableau dans le fichier:

FileWriter fstream1=new FileWriter("outx.txt"); 
BufferedWriter out1= new BufferedWriter(fstream1); 
FileWriter fstream2=new FileWriter("outy.txt"); 
BufferedWriter out2= new BufferedWriter(fstream2); 
for(int i=0;i<320*240;i++) 
{ 

     out1.write(0+System.getProperty("line.separator"));// 
     // out1.write("\n"); 
     out2.write(0+System.getProperty("line.separator")); 
//out2.write("\n"); 

} 

: ici dans le code ci-dessus je mets tous les zéros du fichier devrait contenir 76800 lignes (0s) mais mon fichier n'a que 69932 lignes. quel est le problème et si vous pouvez suggérer un autre moyen de le faire.

Answer 1

Comme d'autres l'ont souligné, il est probable qu'il existe des données dans vos tampons unflushed.

Une façon acceptable de réécrire votre code serait comme ceci:

Writer out1 = new FileWriter("outx.txt"); 
try { 
    out1 = new BufferedWriter(out1); 
    Writer out2 = new FileWriter("outy.txt"); 
    try { 
    out2 = new BufferedWriter(out2); 
    for (int i = 0; i < 320 * 240; i++) { 
     out1.write(0 + System.getProperty("line.separator")); 
     out2.write(0 + System.getProperty("line.separator")); 
    } 
    } finally { 
    out2.close(); 
    } 
} finally { 
    out1.close(); 
} 

Ce code:

• videra données via close
• sera toujours libérer handles de fichiers via close, même si une erreur se produit (en utilisant finally)
• obeys le contrat pour le Closeable cours
• ne muck pas avec nulle ou avalent des exceptions

Answer 2

Ajouter:

out1.flush(); 
out2.flush(); 

Après la boucle.

Il est probable que votre programme se termine avant que les buffers du BufferedReader aient été vidés, ce qui est un problème courant lors de l'utilisation d'une sortie mise en mémoire tampon.

Edit: La solution la plus correcte serait:

public static void main(String[] args) throws IOException { 
    final String outputString = "0" + System.getProperty("line.separator"); 
    BufferedWriter out1 = null; 
    BufferedWriter out2 = null; 
    try { 
     out1 = new BufferedWriter(new FileWriter("outx.txt")); 
     out2 = new BufferedWriter(new FileWriter("outy.txt")); 
     for(int i = 0; i < 320 * 240; i++) { 
      out1.write(outputString); 
      out2.write(outputString); 
     } 
     out1.flush(); // Not really needed as close will flush, but it is 
     out2.flush(); // useful for describing the intent of the code 
    } finally { 
     closeQuietly(out1); 
     closeQuietly(out2); 
    } 
} 

private static void closeQuietly(Closeable c) { 
    try { 
     if (c != null) { 
      c.close(); 
     } 
    } catch (Exception e) { 
     // No-op 
    } 
} 

Answer 3

Avez-vous pensé à fermer les flux de sortie? Votre exemple ne répertorie pas les appels à close(), qui doivent également vider les flux. Le comportement par défaut de BufferedWriter est de vider (écrire) son contenu restant avant de fermer le flux qu'il met en mémoire tampon.

Vous devriez probablement ajouter:

out1.close();
out2.close();

C'est un cas très courant lorsque la fin d'un fichier est coupé que vous avez oublié de fermer l'écrivain utilisé pour créer le fichier, en particulier lorsque vous avez utilisé un BufferedOutputStream ou BufferedWriter qui ne peut pas vider son tampon (écrire dans le fichier) jusqu'à ce qu'il ait été explicitement vidé (ou plus communément, fermé).

C'est une très bonne habitude d'écrire immédiatement l'appel close() après avoir ouvert le flux, puis d'écrire tout votre code pour travailler avec le flux entre les appels. La prise en compte des exceptions, les appels standard utilisent l'idiome suivant:

Writer myOutWriter = null; 
try { 
    myOutWriter = new BufferedWriter(new FileWriter("...")); 
    // Write to myOutWriter here 
} catch (IOException ioe) { 
    // Handle any exceptions here 
} finally { 
    try { 
     if (myOutWriter != null) { 
     myOutWriter.close(); 
     } 
    } catch (IOException ioe) { 
     // Not much you can do here 
    } 
} 

Le projet Apache Commons IO (http://commons.apache.org/io/) a une belle utilitaire appelé IOUtils.closeQuietly() qui nettoie le bloc finally en incluant la prise d'essai, null check, et appel à fermer en un appel de méthode. Un exemple en utilisant cette bibliothèque ressemblerait à ceci:

Writer myOutWriter = null; 
try { 
    myOutWriter = new BufferedWriter(new FileWriter("...")); 
    // Write to myOutWriter here 
} catch (IOException ioe) { 
    // Handle any exceptions here 
} finally { 
    IOUtils.closeQuietly(myOutWriter); 
}