8
votes

BufferedWriter s'arrête au milieu de l'écriture

Pour une raison quelconque, ce code donne un fichier texte.txt tronqué. Il devrait (selon moi) écrire 1000 résultats, mais le fichier de sortie contient diverses quantités de lignes (selon la course). Beirment, l'écriture au fichier s'arrête au milieu de la commande d'écriture, de sorte qu'une ligne peut ne pas être complète. Actuellement, les trois dernières lignes du fichier texte pour la dernière exécution étaient les suivantes:

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Random;

public class ColorGrayScale {

/**
 * @param args
 * @throws IOException
 */
@SuppressWarnings("resource")
public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    Writer out = new BufferedWriter(new FileWriter("test.txt"),16*1024);
    Random generator = new Random();
    float red = 0, green = 0, blue = 0;
    int i = 0;

    while (i<1000) {

        float grey = generator.nextInt(127) + 64;
        int sequence = generator.nextInt(6) + 1; // to pick from 1 of six
                                                    // orders
        switch (sequence) { // the various orders that red green and blue
                            // are going to be in
        case 1:
            red = (float) (generator.nextFloat() * (grey / .21));
            green = (float) (generator.nextFloat() * ((grey - (red * .21)) / .71));
            blue = (float) ((grey - (red * .21) - (green * .71)) / 0.08);
            break;
        case 2:
            red = (float) (generator.nextFloat() * (grey / .21));
            blue = (float) (generator.nextFloat() * ((grey - (red * .21)) / .08));
            green = (float) ((grey - (red * .21) - (blue * .08)) / 0.71);
            break;
        case 3:
            green = (float) (generator.nextFloat() * (grey / .71));
            red = (float) (generator.nextFloat() * ((grey - (green * .71)) / .21));
            blue = (float) ((grey - (red * .21) - (green * .71)) / .08);
            break;
        case 4:
            green = (float) (generator.nextFloat() * (grey / .71));
            blue = (float) (generator.nextFloat() * ((grey - (green * .71)) / .08));
            red = (float) ((grey - (green * .71) - (blue * .08)) / .21);
            break;
        case 5:
            blue = (float) (generator.nextFloat() * (grey / .08));
            red = (float) (generator.nextFloat() * ((grey - (blue * .08)) / .21));
            green = (float) ((grey - (blue * .08) - (red * .21)) / .71);
            break;
        case 6:
            blue = (float) (generator.nextFloat() * (grey / .08));
            green = (float) (generator.nextFloat() * ((grey - (blue * .08)) / .71));
            red = (float) ((grey - (blue * .08) - (green * .71)) / .21);
            break;
        }
        if (red < 256 && blue < 256 && green < 256) {
             out.write("" + i + ", " + red + ", " + green + ", " + blue
                    + ", " + (.21 * red + .71 * green + 0.08 * blue + "\n"));
            i++;
        }
    }
}


1 commentaires

Je pense que vous devez vous assurer que ferme () est appelé sur l'objet out>.


4 Réponses :


2
votes

Vous devriez envisager de rincer votre flux après chaque écriture. Essayez quelque chose comme ceci: xxx

Vous devez également vous assurer de fermer votre flux à la fin de votre opération. Un bon moyen de structurer votre programme pourrait être ceci: xxx


3 commentaires

Pourquoi flush après chaque itération? N'est-ce pas inefficace? Probablement, la taille du tampon pourrait être définie explicitement pour laisser l'auteur décider quand la taille de la mémoire tampon par défaut n'est pas celle souhaitée.


@Vikdor - Je suis d'accord. C'était inefficace. Mise à jour de ma réponse! Merci d'avoir fait remarquer cela :)


Appelant Flush () immédiatement avant Fermer () sur les écrivains standard et les sorties de sortie dans le package Java.io est redondant. Ils s'assurent tous qu'ils rinquissent leur sortie lorsque vous appelez fermer () .



2
votes

Deux choses.

  1. rincer le flux
  2. Fermer le flux

    Essayez quelque chose comme: xxx

    Essayez de vous rappeler, c'est un "tampon". Cela signifie qu'il reste des choses stockées dans la mémoire jusqu'à ce qu'elle décide qu'il doit être écrit ou votre demande explicitement de "affleurer" son contenu.

    aussi, vous devez toujours Fermer VOTRE ruisseaux. Cela empêche les problèmes possibles de fichiers verrouillés et des problèmes de poignée de fichier: P


2 commentaires

Il n'y a pas besoin de flush () le flux à moins que quelque chose d'autre veuille commencer à la lire avant d'avoir fini d'écrire ou il y a une chance que ferme () ne sera jamais appelé .


@Adrianpronk je suis juste paranoïaque: D



17
votes

Vous avez oublié de fermer () l'écrivain, vous n'avez donc jamais eu la chance de rincer la sortie tamponnée sur le disque.


0 commentaires

0
votes

Une fois que vous avez ouvert IO (lecteur, écritures ou bufferr / w, ...), vous devez le fermer ultérieurement pour fermer ce flux et libérer la ressource. Au cas où votre code a imbriqué un flux imbriqué (fichier, fileader, bufferedreader) ou (Writer1, Writer2), Vous devez le fermer séparément d'ordre juste après (bufferedreader, fileaderader, fichier) ou (écrivain1.frose () avant d'utiliser Writer2)


0 commentaires