是否需要分别关闭每个嵌套的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关闭它们，必须在打开它们时将流分配给变量，不能使用嵌套。如果您使用嵌套，则在后续流之一（例如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");
    }
}

...其输出为：

构造示例$ InnerMost
构造示例$ Middle
构造示例$ 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呼叫：

构造示例$ InnerMost
构造示例$ Middle
构造示例$ OuterMost
示例$中间关闭
示例$内部最封闭
示例$内部最封闭
在捕获块中
在最后块
主末

（是的，两个to的调用InnerMost#close是正确的；一个来自from Middle，另一个来自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，或者您将不再需要它，那么您应该只添加您实际需要的代码。您不应添加您可能想像的代码，但实际上并没有做任何有用的事情。

举个例子，想象一下如果不这样做可能会出什么问题，会带来什么影响？

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

让我们从FileOutputStream开始，后者open执行所有实际工作。

/**
 * 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)) {
      ...
}

如果只关闭最后一个流，那就没问题了-close调用也将发送到基础流。

否，最高层，Stream否则reader将确保关闭所有基础流/阅读器。

检查最顶层流的close()方法实现。

在Java 7中，有一个功能try-with-resources。您无需显式关闭流，它将解决此问题。