Ce qui arrive à un BufferedReader qui n'est pas fermé à l'intérieur d'un appelable.appel?

Je dirais que depuis qu'ils sont la création d'un BufferedReader autour d'un même InputStream, le code est sûr de ne pas appeler close(). Le code qui appelle close() devrait toujours être le code qui crée le flux et le fait à l'aide de try/finally.

public static void read(String str) throws IOException {
    FileInputStream stream = null
    try {
        stream = new FileInputStream(str);
        readStreamToConsole(stream);
    } finally {
        if (stream != null)
            stream.close();
    }
}

private static void readStreamToConsole(InputStream stream) {
    BufferedReader stdOut = new BufferedReader(new InputStreamReader(stream));
    String output = null;
    while ((output = stdOut.readLine()) != null)
        System.out.println(output);
}

Une autre remarque: le code semble être sortie d'enregistrement à partir d'un autre processus. Vous n'auriez probablement pas être en mesure de fermer le flux de données, de toute façon. Sans le tester moi-même, je ne suis pas sûr de ce qui se passerait si vous avez fermé un flux à partir d'un autre processus.

Oh, et le IOException n'est pas susceptible de se produire parce que le flux est à venir à partir d'un autre processus. C'est pas susceptible de se produire à moins que certains d'erreur irrécupérable se produit. Ce ne serait pas encore une mauvaise idée pour vous connecter à l'exception d'une certaine manière, cependant.

---

Modifier à l'adresse de votre commentaire au sujet des réponses mitigées:

Nous allons utiliser un flux de sortie et BufferedWriter comme un exemple de ce temps:

private static final String NEWLINE = System.getProperty("line.separator");

public static void main(String[] args) throws IOException {
    String file = "foo/bar.txt";
    FileOutputStream stream = null;
    try {
        stream = new FileOutputStream(file);
        writeLine(stream, "Line 1");
        writeLine(stream, "Line 2");
    } finally {
        if (stream != null)
            stream.close();
    }
}

private static void writeLine(OutputStream stream, String line) throws IOException {
    BufferedWriter writer = new BufferedWriter(new InputStreamWriter(stream));
    writer.write(line + NEWLINE);
}

Cela fonctionne. La méthode writeLine est utilisé en tant que délégué à la création de writer et en train d'écrire une seule line pour le fichier. Bien sûr, cette logique pourrait être quelque chose de plus complexe, telle que la transformation d'un objet dans un String et de l'écriture. Cela rend le main méthode un peu plus facile à lire.

Maintenant, si au lieu de cela, nous avons fermé la BufferedWriter?

private static void writeLine(OutputStream stream, String line) throws IOException {
    BufferedWriter writer = null;
    try {
        writer = new BufferedWriter(new InputStreamWriter(stream));
        writer.write(line + NEWLINE);
    } finally {
        if (writer != null)
            writer.close();
    }
}

Essayer de l'exécuter, et il échouera à chaque fois sur la deuxième writeLine appel. C'est une bonne pratique de toujours à proximité des cours d'eau où ils sont créés, au lieu d'où ils sont passés. Il peut être bien au début, mais ensuite, essayer de modifier le code plus tard, pourrait provoquer des erreurs. Si j'ai commencé avec seulement 1 writeLine appel avec la mauvaise méthode et quelqu'un d'autre veut ajouter une seconde, ils auraient à refactoriser le code de sorte que writeLine ne pas fermer le flux de données, de toute façon. Approchez-heureux peut causer des maux de tête en bas de la route.

Noter également que, techniquement, la BufferedWriter n'est pas la réelle gérer vos ressources système, l' FileOutputStream est, de sorte que vous devriez être à la clôture, le véritable ressource de toute façon.

Donc, la règle de base: seules près de votre cours d'eau où vous les créez, et toujours faire de la création et de clôture dans un try/finally bloc (ou Java 7 est génial essayez de ressources de bloc, qui ne la clôture pour vous).

OriginalL'auteur Brian

Vous ne voulez pas fermer la BufferedReader dans ce cas. Le InputStream qui a été adoptée pour le constructeur est l'objet qui peut être associé à un système de ressources. Le BufferedReader et la InputStreamReader sont juste des wrappers autour de cela. La fermeture de la BufferedReader serait aussi fermer la InputStream, qui peut ne pas être ce que l'appelant voulait.

OriginalL'auteur Kenster

N'importe où vous ouvrez le flux, vous devriez la fermer dans le bloc finally et c'est une bonne pratique pour tester le flux de null ainsi, parce que si le fichier n'est pas en vigueur le flux sera null, une exception sera levée (FileNotFoundException) mais enfin bock est fait. I. e. le contenu de l'appel de la méthode doit être:

   BufferedReader stdOut = null;
   String output = null;
        try {
            stdOut = new BufferedReader(new InputStreamReader(stream));
            while ((output = stdOut.readLine()) != null) {
                log.info("[" + prepend + "] " + output);
            }
        } catch (FileNotFoundException ex) {
            log.warn("Unable to open nonexisten file " + whichOne);  
        } catch (IOException ex) {
            log.warn("Unable to read from stream");  
        } finally {
            if (stdOut != null) {
                try {
                   stdOut.close();
                } catch (IOException e) {
                    log.warn("Unable to close the stream");
                }
            }
        }
        return 0;

Ou si vous êtes autorisé à utiliser Java 7, vous pouvez utiliser les avantages de AutoCloseable de l'interface et la nouvelle structure de la langue à cette fin.
voir http://www.oracle.com/technetwork/articles/java/trywithresources-401775.html

OriginalL'auteur Jiri Kremser