ネストされた各OutputStreamおよびWriterを個別に閉じる必要がありますか？

私はコードの一部を書いています：

OutputStream outputStream = new FileOutputStream(createdFile);
GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(gzipOutputStream));

次のようにすべてのストリームまたはライターを閉じる必要がありますか？

gzipOutputStream.close();
bw.close();
outputStream.close();

または、最後のストリームを閉じるだけで問題ありませんか？

bw.close();

すべてのストリームbwが正常に作成されると仮定すると、そうです、これらのストリーム実装では、閉じるだけで問題ありません。しかし、それは大きな仮定です。

私はtry-with-resources（チュートリアル）を使用して、例外をスローする後続のストリームを構築する際に問題が発生しても、前のストリームがハングアップしないようにします。そのため、closeを呼び出すストリーム実装に依存する必要はありません。基になるストリーム：

try (
    OutputStream outputStream = new FileOutputStream(createdFile);
    GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
    OutputStreamWriter osw = new OutputStreamWriter(gzipOutputStream);
    BufferedWriter bw = new BufferedWriter(osw)
    ) {
    // ...
}

もう電話しないことに注意してください closeし。

重要な注意：try-with-resourcesでそれらを閉じるには、ストリームを開くときに変数に割り当てる必要があります。ネストは使用できません。ネストを使用する場合、後のストリームの1つ（たとえばGZIPOutputStream）の構築中に例外が発生すると、その中にネストされた呼び出しによって構築されたストリームが開いたままになります。JLS§14.20.3から：

try-with-resourcesステートメントは、ブロックの実行前に初期化され、ブロックの実行後に初期化されたときとは逆の順序で自動的に閉じられる変数（リソース）でパラメーター化tryされますtry。

「変数」という言葉に注目してください（私の強調）。

たとえば、これを行わないでください：

// DON'T DO THIS
try (BufferedWriter bw = new BufferedWriter(
        new OutputStreamWriter(
        new GZIPOutputStream(
        new FileOutputStream(createdFile))))) {
    // ...
}

... GZIPOutputStream(OutputStream)コンストラクタからの例外（スローする可能性がありIOException、基になるストリームにヘッダーを書き込む）が原因でFileOutputStreamオープンのままになるためです。一部のリソースにはスローする可能性のあるコンストラクターがあり、他のリソースにはないコンストラクターがあるため、それらを個別にリストすることは良い習慣です。

このプログラムを使用して、JLSセクションの解釈を再確認できます。

public class Example {

    private static class InnerMost implements AutoCloseable {
        public InnerMost() throws Exception {
            System.out.println("Constructing " + this.getClass().getName());
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
        }
    }

    private static class Middle implements AutoCloseable {
        private AutoCloseable c;

        public Middle(AutoCloseable c) {
            System.out.println("Constructing " + this.getClass().getName());
            this.c = c;
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
            c.close();
        }
    }

    private static class OuterMost implements AutoCloseable {
        private AutoCloseable c;

        public OuterMost(AutoCloseable c) throws Exception {
            System.out.println("Constructing " + this.getClass().getName());
            throw new Exception(this.getClass().getName() + " failed");
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
            c.close();
        }
    }

    public static final void main(String[] args) {
        // DON'T DO THIS
        try (OuterMost om = new OuterMost(
                new Middle(
                    new InnerMost()
                    )
                )
            ) {
            System.out.println("In try block");
        }
        catch (Exception e) {
            System.out.println("In catch block");
        }
        finally {
            System.out.println("In finally block");
        }
        System.out.println("At end of main");
    }
}

...出力があります：

Example $ InnerMostの作成
Example $ Middleの構築
Example $ OuterMostの構築
キャッチブロック内
最後にブロックで
メインの終わりに

そこへの呼び出しがないことに注意してくださいclose。

修正するとmain：

public static final void main(String[] args) {
    try (
        InnerMost im = new InnerMost();
        Middle m = new Middle(im);
        OuterMost om = new OuterMost(m)
        ) {
        System.out.println("In try block");
    }
    catch (Exception e) {
        System.out.println("In catch block");
    }
    finally {
        System.out.println("In finally block");
    }
    System.out.println("At end of main");
}

次に、適切なclose呼び出しを取得します。

Example $ InnerMostの作成
Example $ Middleの構築
Example $ OuterMostの構築
例$ミドル閉鎖
例$ InnerMost closed
例$ InnerMost closed
キャッチブロック内
最後にブロックで
メインの終わりに

（はい、2つの呼び出しInnerMost#closeは正しいです。1つはからMiddle、もう1つはtry-with-resourcesからです。）

最も外側のストリームを閉じることができます。実際には、すべてのストリームをラップして保持する必要はなく、Java 7のtry-with-resourcesを使用できます。

try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                     new GZIPOutputStream(new FileOutputStream(createdFile)))) {
     // write to the buffered writer
}

YAGNIまたはyou-aint-gonna-need-itを購読している場合は、実際に必要なコードのみを追加する必要があります。必要と思われるコードを追加するべきではありませんが、実際には何も有用ではありません。

この例を見て、これを実行しなかった場合に何が問題になる可能性があり、どのような影響があるかを想像してみてください。

try (
    OutputStream outputStream = new FileOutputStream(createdFile);
    GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
    OutputStreamWriter osw = new OutputStreamWriter(gzipOutputStream);
    BufferedWriter bw = new BufferedWriter(osw)
    ) {
    // ...
}

open実際の作業をすべて実行するために呼び出すFileOutputStreamから始めましょう。

/**
 * Opens a file, with the specified name, for overwriting or appending.
 * @param name name of file to be opened
 * @param append whether the file is to be opened in append mode
 */
private native void open(String name, boolean append)
    throws FileNotFoundException;

ファイルが見つからない場合、閉じる基礎となるリソースがないため、ファイルを閉じても違いはありません。ファイルが存在する場合は、FileNotFoundExceptionをスローする必要があります。したがって、この行だけからリソースを閉じようとしても、何も得られません。

ファイルを閉じる必要があるのは、ファイルが正常に開かれたときですが、後でエラーが発生します。

次のストリームを見てみましょう GZIPOutputStream

例外をスローできるコードがあります

private void writeHeader() throws IOException {
    out.write(new byte[] {
                  (byte) GZIP_MAGIC,        // Magic number (short)
                  (byte)(GZIP_MAGIC >> 8),  // Magic number (short)
                  Deflater.DEFLATED,        // Compression method (CM)
                  0,                        // Flags (FLG)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Extra flags (XFLG)
                  0                         // Operating system (OS)
              });
}

これにより、ファイルのヘッダーが書き込まれます。これで、書き込み用にファイルを開くことができても、8バイトも書き込むことができないのは非常に珍しいことですが、これが発生する可能性があり、後でファイルを閉じないことを想像してみてください。ファイルを閉じないとどうなりますか？

フラッシュされていない書き込みは取得されず、破棄されます。この場合、この時点ではバッファリングされていないストリームに正常に書き込まれたバイトはありません。しかし、閉じられていないファイルは永遠に生きるわけではなく、代わりにFileOutputStreamが持っています

protected void finalize() throws IOException {
    if (fd != null) {
        if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
            flush();
        } else {
            /* if fd is shared, the references in FileDescriptor
             * will ensure that finalizer is only called when
             * safe to do so. All references using the fd have
             * become unreachable. We can call close()
             */
            close();
        }
    }
}

ファイルをまったく閉じない場合は、すぐにではなく、とにかく閉じられます（前述のように、バッファーに残っているデータはこの方法で失われますが、現時点ではありません）。

ファイルをすぐに閉じないとどうなりますか？通常の状態では、一部のデータが失われる可能性があり、ファイル記述子が不足する可能性があります。しかし、ファイルを作成できるシステムにファイルを書き込むことができないシステムがある場合、より大きな問題が発生します。つまり、失敗しているにもかかわらずこのファイルを繰り返し作成しようとしている理由を想像するのは困難です。

OutputStreamWriterとBufferedWriterはどちらもコンストラクタでIOExceptionをスローしないため、どのような問題が発生するかは明確ではありません。BufferedWriterの場合、OutOfMemoryErrorが発生する可能性があります。この場合、GCがすぐにトリガーされます。これまで見てきたように、とにかくファイルを閉じます。

すべてのストリームがインスタンス化されている場合は、最も外側のストリームのみを閉じても問題ありません。

Closeableインターフェイスに関するドキュメントには、そのcloseメソッドが記載されています。

このストリームを閉じ、それに関連付けられているすべてのシステムリソースを解放します。

システムリソースの解放には、ストリームのクローズが含まれます。

また、次のように述べています。

ストリームがすでに閉じている場合、このメソッドを呼び出しても効果はありません。

したがって、後で明示的に閉じても問題はありません。

try(...)構文（Java 7）を使用したい、たとえば

try (OutputStream outputStream = new FileOutputStream(createdFile)) {
      ...
}

最後のストリームのみを閉じれば問題はありません。閉じる呼び出しも基になるストリームに送信されます。

いいえ、最上位レベル、Streamまたはreaderすべての基になるストリーム/リーダーが確実に閉じられます。

最上位レベルのストリームのclose()メソッド実装を確認してください。

Java 7には、try-with-resourcesという機能があります。ストリームを明示的に閉じる必要はありません。それが処理されます。