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++; } } }
4 Réponses :
Vous devriez envisager de rincer votre flux après chaque écriture. Essayez quelque chose comme ceci: 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: p>
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 () Code> immédiatement avant
Fermer () Code> 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 () code>.
Deux choses.
Essayez quelque chose comme: p> 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. P> aussi, vous devez toujours Fermer CODE> VOTRE ruisseaux. Cela empêche les problèmes possibles de fichiers verrouillés et des problèmes de poignée de fichier: P p> p>
Il n'y a pas besoin de flush () code> 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 () code> ne sera jamais appelé .
@Adrianpronk je suis juste paranoïaque: D
Vous avez oublié de fermer () l'écrivain, vous n'avez donc jamais eu la chance de rincer la sortie tamponnée sur le disque. P>
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) P>
Je pense que vous devez vous assurer que
ferme () code> est appelé sur l'objet
out>.