Devo chiudere () sia FileReader che BufferedReader?

Sto leggendo un file locale usando un BufferedReader racchiuso in un FileReader:

BufferedReader reader = new BufferedReader(new FileReader(fileName));
// read the file
// (error handling snipped)
reader.close();

Devo close()la FileReadercosì, o sarà la maniglia wrapper che? Ho visto codice in cui le persone fanno qualcosa del genere:

FileReader fReader = new FileReader(fileName);
BufferedReader bReader = new BufferedReader(fReader);
// read the file
// (error handling snipped)
bReader.close();
fReader.close();

Questo metodo viene chiamato da un servlet e vorrei assicurarmi di non lasciare alcun handle aperto.

no.

BufferedReader.close()

chiude il flusso in base a javadoc per BufferedReader e InputStreamReader

così come

FileReader.close()

lo fa.

Come altri hanno sottolineato, è sufficiente chiudere l'involucro esterno.

BufferedReader reader = new BufferedReader(new FileReader(fileName));

Esiste una probabilità molto ridotta che ciò possa perdere un handle di file se il BufferedReadercostruttore ha generato un'eccezione (ad esempio OutOfMemoryError). Se la tua app è in questo stato, quanto deve essere accurata la tua pulizia potrebbe dipendere da quanto sia fondamentale non privare il sistema operativo delle risorse che potrebbe voler allocare ad altri programmi.

L' interfaccia Closeable può essere utilizzata se è probabile che un costruttore wrapper non riesca in Java 5 o 6:

Reader reader = new FileReader(fileName);
Closeable resource = reader;
try {
  BufferedReader buffered = new BufferedReader(reader);
  resource = buffered;
  // TODO: input
} finally {
  resource.close();
}

Il codice Java 7 dovrebbe usare il modello try-with-resources :

try (Reader reader = new FileReader(fileName);
    BufferedReader buffered = new BufferedReader(reader)) {
  // TODO: input
}

Secondo la fonte BufferedReader, in questo caso bReader.close chiama fReader.close quindi tecnicamente non è necessario chiamare quest'ultimo.

Il codice sorgente per BufferedReader mostra che il sottostante è chiuso quando si chiude BufferedReader.

Dopo aver verificato il codice sorgente, ho scoperto che per l'esempio:

FileReader fReader = new FileReader(fileName);
BufferedReader bReader = new BufferedReader(fReader);

il metodo close () sull'oggetto BufferedReader chiamerebbe il metodo abstract close () della classe Reader che alla fine chiamerebbe il metodo implementato nella classe InputStreamReader , che quindi chiude l' oggetto InputStream .

Pertanto, è sufficiente solo bReader.close ().

A partire da Java 7 è possibile utilizzare l' istruzione try-with-resources

try (BufferedReader br = new BufferedReader(new FileReader(path))) {
    return br.readLine();
}

Poiché l' BufferedReaderistanza viene dichiarata in un'istruzione try-with-resource, verrà chiusa indipendentemente dal fatto che l'istruzione try venga completata normalmente o bruscamente. Quindi non è necessario chiuderlo da soli finallynell'istruzione. (Questo è anche il caso delle dichiarazioni di risorse nidificate)

Questo è il modo consigliato per lavorare con le risorse, vedere la documentazione per informazioni più dettagliate

Devi solo chiudere bufferedReader, ad esempio reader.close () e funzionerà benissimo.

Sono in ritardo, ma:

BufferReader.java:

public BufferedReader(Reader in) {
  this(in, defaultCharBufferSize);
}

(...)

public void close() throws IOException {
    synchronized (lock) {
        if (in == null)
            return;
        try {
            in.close();
        } finally {
            in = null;
            cb = null;
        }
    }
}

È Do not necessario chiudere il lettore / scrittore avvolto.

Se hai dato un'occhiata ai documenti ( Reader.close(), Writer.close()), vedrai che in Reader.close()esso dice:

Chiude lo stream e rilascia tutte le risorse di sistema ad esso associate.

Il che dice semplicemente che "libera tutte le risorse di sistema ad esso associate ". Anche se non conferma .. ti dà una spinta per iniziare a sembrare più profondo. e se ci vai Writer.close()afferma solo che si chiude da solo.

In questi casi, ci riferiamo a OpenJDK per dare un'occhiata al codice sorgente.

A BufferedWriter Line 265 vedrai out.close(). Quindi non si chiude da solo .. È qualcos'altro. Se cerchi le occorrenze di " out" nella classe noterai che nel costruttore alla riga 87 che outè lo scrittore la classe si sposta dove chiama un altro costruttore e quindi assegna il outparametro alla propria outvariabile.

Quindi .. E gli altri? Puoi vedere un codice simile su BufferedReader Line 514 , BufferedInputStream Line 468 e InputStreamReader Line 199 . Altri non lo so, ma questo dovrebbe essere sufficiente per supporre che lo facciano.