前言
在jdk1.7以前，io的操作都是要关流的，而经常有些码农就会忘记关流(比如说我)，从而造成资源的浪费，降低系统性能。但值的高兴的是，在jdk1.7以后就不用关流了，流会自动关闭,，这样一来，我们就不用担心关流的问题了。就在刚出版的jdk1.9中又对jdk1.7中的方式又做新的更新，先不急了解新写法，我们先从jdk1.7之前出现，看看之前关流的做法是怎样的。tip：如果想使用这种糖语法关流，就必须实现AutoColseable接口，才可以自动关流
AutoColseable接口源码：
public interface AutoCloseable {
void close() throws Exception;
}
JDK1.7之前关流方式
jdk1.7之前，在finally块(并不一定要在finally块中)中执行close()方法，关闭流并释放与该流关联的所有系统资源。这样一来，每打开一个连接，就要关一次连接。
public static void testBuffered(File file) throws IOException {
BufferedInputStream bis = null;
try {
bis = new BufferedInputStream(new FileInputStream(file));
byte[] b = new byte[bis.available()];
bis.read(b);
System.out.println("使用缓冲字节输入流读取到的结果如下："+new String(b));
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
//关闭流bis.close();
}
}
JDK1.7新语法
在JDK1.7以前，Java没有自动关闭外部资源的语法特性，直到JDK7中新增了try-with-resource语法，才实现了这一功能。简单的demo我也写了一个，放在下面...
package com.java.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/*** java7新写法* Java7* 创建人:罗祥* 时间：2018年4月13日-下午10:50:48* @version 1.0.0**/
public class Java7 {
public static void main(String[] args) {
File file = new File("D:"+File.separator+"罗祥.txt");
try(
FileInputStream fis = new FileInputStream(file);
) {
byte[] b = new byte[fis.available()];
fis.read(b);
System.out.println("文件读取内容如下："+new String(b));
} catch (IOException e) {
e.printStackTrace();
}
}
}
只要把需要关流的操作写在try()中就可以不用关流，不需要关流的操作(准确来说是没有实现AtuoColseable接口的类)，不能写在try()中，否则报错。
JDK1.9新语法
JDK9发布后，又简化了try-with-resources语句的用法。try()里面可以是一个变量，但必须是final的或者等同final才行。如下面的mis，mos定义成局部变量可以不用final，局部变量可以等同于final，但定义成成员变量就必须是用final修饰的，不然会编译错误。
声明：讲到这个9的语法，由于我的pc上最高只安装了8的版本，所以无法测试这种语法，下面这个demo是我复制这个网站的demo:JDK9新特性实战：流关闭新姿势 - Java技术栈 - 博客园​www.cnblogs.com
MyInputStream mis = new MyInputStream();
MyOutputStream mos = new MyOutputStream();
try (mis; mos) {
mis.read("1.9");
mos.write("1.9");
} catch (Exception e) {
e.printStackTrace();
}
简略的谈一下个人对9的语法的感觉，总体来来说，比7的版本的中的语法看的让人更舒服，然后就是没有什么太大的区别了。说白了这些语法糖，表面上我们没有手动关流，其实在运行期间，还是调用close()方法进行关流的，只是这一步不用我们去做了。
总结
闲话不多扯，做个总结，总之要想实现自动关流，还是想看连接类有没有实现AutoColseable这个接口，具体可以查看源码，这里不作详细解释。
参考文章：Java进阶知识点3：更优雅地关闭资源 - try-with-resource及其异常抑制​www.cnblogs.com

关闭流的实例在下面，往后拖就OK了
问题：
(1)JAVA的IO流使用了装饰模式,关闭最外面的流的时候会自动调用被包装的流的close()方吗？
(2)如果按顺序关闭流，是从内层流到外层流关闭还是从外层到内存关闭？
问题(1)解释：
如下例子代码：
FileInputStream is = new FileInputStream(".");
BufferedInputStream bis = new BufferedInputStream(is);
bis.close();
从设计模式上看：
java.io.BufferedInputStream是java.io.InputStream的装饰类。
BufferedInputStream装饰一个 InputStream 使之具有缓冲功能，is要关闭只需要调用最终被装饰出的对象的 close()方法即可，因为它最终会调用真正数据源对象的 close()方法。
BufferedInputStream的close方法中对InputStream进行了关闭，下面是jdk中附带的源代码：
java.io.BufferedInputStream的api:
close
public void close()throws IOException 关闭此输入流并释放与该流关联的所有系统资源。
因此，可以只调用外层流的close方法关闭其装饰的内层流，验证例子：
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("d:\\a.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
bw.write("java IO close test");
bw.close();
}
验证ok
问题(2)解释：如果不想使用(1)方式关闭流，可以逐个关闭流(可能大家比较习惯吧)
如下例子：
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("d:\\a.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
bw.write("java IO close test");
//从内带外顺序顺序会报异常
fos.close();
osw.close();
bw.close();
}
报出异常：
Exception in thread "main" java.io.IOException: Stream closed
at sun.nio.cs.StreamEncoder.ensureOpen(StreamEncoder.java:26)
at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:99)
at java.io.OutputStreamWriter.write(OutputStreamWriter.java:190)
at java.io.BufferedWriter.flushBuffer(BufferedWriter.java:111)
at java.io.BufferedWriter.close(BufferedWriter.java:246)
at com.my.test.QQ.main(QQ.java:22)
如下例子：
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("d:\\a.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
bw.write("java IO close test");
// 从外到内顺序关闭ok
bw.close();
osw.close();
fos.close();
}
验证ok
一般情况下是：先打开的后关闭，后打开的先关闭
另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b
例如处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
当然完全可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法
如果将节点流关闭以后再关闭处理流，会抛出IO异常；
我们深知在操作Java流对象后要将流关闭，但往往事情不尽人意，大致有以下几种不能一定将流关闭的写法：
1.在try中关流，而没在finally中关流
try {
OutputStream out = new FileOutputStream("");
// ...操作流代码
out.close();
} catch (Exception e) {
e.printStackTrace();
}
正确写法：
OutputStream out = null;
try {
out = new FileOutputStream("");
// ...操作流代码
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (out != null) {
out.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
2.在关闭多个流时因为嫌麻烦将所有关流的代码丢到一个try中
OutputStream out = null;
OutputStream out2 = null;
try {
out = new FileOutputStream("");
out2 = new FileOutputStream("");
// ...操作流代码
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (out != null) {
out.close();// 如果此处出现异常，则out2流没有被关闭
}
if (out2 != null) {
out2.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
正确写法：
OutputStream out = null;
OutputStream out2 = null;
try {
out = new FileOutputStream("");
out2 = new FileOutputStream("");
// ...操作流代码
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (out != null) {
out.close();// 如果此处出现异常，则out2流也会被关闭
}
} catch (Exception e) {
e.printStackTrace();
}
try {
if (out2 != null) {
out2.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
3.在循环中创建流，在循环外关闭，导致关闭的是最后一个流
OutputStream out = null;
try {
for (int i = 0; i 
out = new FileOutputStream("");
// ...操作流代码
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (out != null) {
out.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
正确写法：
for (int i = 0; i 
OutputStream out = null;
try {
out = new FileOutputStream("");
// ...操作流代码
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (out != null) {
out.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
PS：在Java7中，关闭流这种繁琐的事情再也不用我们自己敲代码了：
try (OutputStream out = new FileOutputStream("")){
// ...操作流代码
} catch (Exception e) {
e.printStackTrace();
}
只要实现的自动关闭接口(Closeable)的类都可以在try结构体上定义，java会自动帮我们关闭，及时在发生异常的情况下也会。可以在try结构体上定义多个，用分号隔开即可,如：
try (OutputStream out = new FileOutputStream("");OutputStream out2 = new FileOutputStream("")){
// ...操作流代码
} catch (Exception e) {
throw e;
}

问题：
(1)JAVA的IO流使用了装饰模式,关闭最外面的流的时候会自动调用被包装的流的close()方吗？
(2)如果按顺序关闭流，是从内层流到外层流关闭还是从外层到内存关闭？
问题(1)解释：
如下例子代码：
从设计模式上看：
java.io.BufferedInputStream是java.io.InputStream的装饰类。
BufferedInputStream装饰一个 InputStream 使之具有缓冲功能，is要关闭只需要调用最终被装饰出的对象的 close()方法即可，因为它最终会调用真正数据源对象的 close()方法。
BufferedInputStream的close方法中对InputStream进行了关闭，下面是jdk中附带的源代码：
java.io.BufferedInputStream的api:
close
public void close()throws IOException 关闭此输入流并释放与该流关联的所有系统资源。
因此，可以只调用外层流的close方法关闭其装饰的内层流，验证例子：
验证ok
问题(2)解释：如果不想使用(1)方式关闭流，可以逐个关闭流(可能大家比较习惯吧)
如下例子：
报出异常：
Exception in thread "main" java.io.IOException: Stream closed
at sun.nio.cs.StreamEncoder.ensureOpen(StreamEncoder.java:26)
at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:99)
at java.io.OutputStreamWriter.write(OutputStreamWriter.java:190)
at java.io.BufferedWriter.flushBuffer(BufferedWriter.java:111)
at java.io.BufferedWriter.close(BufferedWriter.java:246)
at com.my.test.QQ.main(QQ.java:22)
如下例子：
验证ok
一般情况下是：先打开的后关闭，后打开的先关闭
另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b
例如处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
当然完全可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法
如果将节点流关闭以后再关闭处理流，会抛出IO异常；

问题：
(1)JAVA的IO流使用了装饰模式,关闭最外面的流的时候会自动调用被包装的流的close()方吗？
(2)如果按顺序关闭流，是从内层流到外层流关闭还是从外层到内存关闭？
问题(1)解释：
如下例子代码：
FileInputStream is = new FileInputStream(".");
BufferedInputStream bis = new BufferedInputStream(is);
bis.close();
从设计模式上看：
java.io.BufferedInputStream是java.io.InputStream的装饰类。
BufferedInputStream装饰一个 InputStream 使之具有缓冲功能，is要关闭只需要调用最终被装饰出的对象的 close()方法即可，因为它最终会调用真正数据源对象的 close()方法。
BufferedInputStream的close方法中对InputStream进行了关闭，下面是jdk中附带的源代码：
java.io.BufferedInputStream的api:
close
public void close()throws IOException 关闭此输入流并释放与该流关联的所有系统资源。
因此，可以只调用外层流的close方法关闭其装饰的内层流，验证例子：
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("d:\\a.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
bw.write("java IO close test");
bw.close();
}
验证ok
问题(2)解释：如果不想使用(1)方式关闭流，可以逐个关闭流(可能大家比较习惯吧)
如下例子：
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("d:\\a.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
bw.write("java IO close test");
//从内带外顺序顺序会报异常
fos.close();
osw.close();
bw.close();
}
报出异常：
Exception in thread "main" java.io.IOException: Stream closed
at sun.nio.cs.StreamEncoder.ensureOpen(StreamEncoder.java:26)
at sun.nio.cs.StreamEncoder.write(StreamEncoder.java:99)
at java.io.OutputStreamWriter.write(OutputStreamWriter.java:190)
at java.io.BufferedWriter.flushBuffer(BufferedWriter.java:111)
at java.io.BufferedWriter.close(BufferedWriter.java:246)
at com.my.test.QQ.main(QQ.java:22)
如下例子：
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("d:\\a.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedWriter bw = new BufferedWriter(osw);
bw.write("java IO close test");
// 从外到内顺序关闭ok
bw.close();
osw.close();
fos.close();
}
验证ok
一般情况下是：先打开的后关闭，后打开的先关闭
另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b
例如处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
当然完全可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法
如果将节点流关闭以后再关闭处理流，会抛出IO异常；
转自http://www.cnblogs.com/qqzy168/p/3670915.html