java程序中的流都要统统关闭吗？有没有先后顺序？？
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java程序中的流都要统统关闭吗？有没有先后顺序？？相关的知识，希望对你有一定的参考价值。
理论上都得关闭，流就是把硬盘上的东西放到内存上，不关就会浪费资源关当然有先后顺序，我找了点解释：
一般情况下是：先打开的后关闭，后打开的先关闭
另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b
例如处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b
当然完全可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法
如果将节点流关闭以后再关闭处理流，会抛出IO异常追问
例如：InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
br.close();//先关依赖流
isr.close();
是这样对吧？
还有那个节点流是不是字节流，对这个概念不太懂，处理流也不懂，能指个具体例子吗？跪求啦！！！
流按照不同分类，有字节流和字符流之分，还有节点流和处理流之分，不是一类概念。最根本的流有InputStream，OutputStream，Writer，Reader，任何关于流的处理都是对应这四种流（最后作为参数传递给某个处理流），按照我的理解（因为实在是没分过处理流和节点流~~），包在外边的流都是处理流，按照你举的例子，当调用了某个处理流的方法，就必须先关闭处理流，这是很容易理解的道理，比如说调用了br.read()方法，因为这个方法是阻塞式的，br是从isr中读，isr从System.in中读，直接把System.in关了肯定会抛异常；
参考技术A如果使用的是jdk7.
自动的资源管理机制
在 Java 程序中，处理所有可能的失败路径是困难的，关闭资源也是相对困难的，因此在 Java 7 的实现中，资源管理获得了编译器的帮助，通过定义一个在资源上接口使得编译器能够自动在合适的时候来关闭资源，释放内存等资源。
自动资源管理示例
OutputStream outFile = new FileOutputStream(aFileName))
byte[] buf = new byte[BUF_SIZE];
int readBytes;
while ((readBytes = inFile.read(buf)) >= 0)
inFile.write(buf, readBytes);
参考技术B 自己程序打开的，要关闭 参考技术C 不知道为什么有一种说法 先打开的后关闭 后打开先关闭.但是他们这些人一直在复制粘贴这些,也不解释道理. 我觉得 先关闭外层流的时候 他会自己调用内层流的close方法 只需要关闭最外层一个就可以.如果先从外层开始关 也没有问题,逐一关闭即可.
Java基础学习——I/O
1.流的概念
在java中，流(stream)是从源到目的地的字节的有序序列。流中的字节依据先进先出，具有严格顺序，因此流式I/O是一种顺序存取方式。
2.两种基本的流
在java中有两种基本——输入流(InputStream)与输出流(OutputStream)，对于这两种流都采用相同的顺序读写方式，其读写操作过程如下：
流的读操作过程，打开流—>当流中还有数据时执行读操作—>关闭流
流的写操作过程，打开流—>当有数据需要输出时执行写操作—>关闭流。
Java中实现上述流式I/O的类都在java.io包中。
这些流根据流相对于程序的另一个端点的不同，分为节点流（Node Stream）和过滤流（Filter Stream）
节点流：以特定流如磁盘文件、内存某区域或线程之间的管道为端点构造的输入/输出流,它是一种最基本的流。
过滤流：以其他已经存在的流为端点构造的输入/输出流,称为过滤流或者处理流,它要对其相连的另一种流进行某种转换。
流根据数据单位不同又分为字节流和字符流：字节流（8位）和字符流（16位）。
3.字节流（其中带阴影的内是节点流,其他为过滤流）
1.输入字节流
InputStream是输入字节流的抽象顶层父类。
2.输出字节流
4.字符流
1.输入字符流
2.输出字符流
5.经常使用的流
节点流类型常见的有：
对文件操作的字节流有FileInputStream/FileOutputStream，
字符流有FileReader/FileWriter。
处理流类型常见的有：
缓冲流：缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写效率，同事增加了一些新的方法。
字节缓冲流有BufferedInputStream/BufferedOutputStream，
字符缓冲流有BufferedReader/BufferedWriter，字符缓冲流分别提供了读取和写入一行的方法ReadLine和NewLine方法。
对于输出地缓冲流，写出的数据，会先写入到内存中，再使用flush方法将内存中的数据刷到硬盘。所以，在使用字符缓冲流的时候，一定要先flush，然后再close，避免数据丢失。
转换流：用于字节数据到字符数据之间的转换。
仅有字符流InputStreamReader/OutputStreamWriter。其中，InputStreamReader需要与InputStream“套接”，OutputStreamWriter需要与OutputStream“套接”。
数据流：提供了读写Java中的基本数据类型的功能。
DataInputStream和DataOutputStream分别继承自InputStream和OutputStream，需要“套接”在InputStream和OutputStream类型的节点流之上。
对象流：用于直接将对象写入写出。
流类有ObjectInputStream和ObjectOutputStream，本身这两个方法没什么，但是其要写出的对象有要求，该对象必须实现Serializable接口，来声明其是可以序列化的。否则，不能用对象流读写。
6.使用实例
-
输入字节流：FileInputStream
--------| InputStream 所有输入字节流的基类 抽象类
------------| FileInputStream 读取文件数据的输入字节流
使用FileInputStream读取文件数据的步骤：
1. 找到目标文件
2. 建立数据的输入通道。
3. 读取文件中的数据。
4. 关闭 资源.
在使用时经常会使用自定义的缓冲数组以加快读取速度。
1 public class MyFileInputStream { 2 3 public static void main(String[] args) throws IOException { 4 readTest4(); 5 } 6 7 //使用缓冲数组配合循环一起读取。 推荐使用 8 public static void readTest4() throws IOException{ 9 long startTime = System.currentTimeMillis(); 10 //找到目标文件 11 File file = new File("F:\\\\81179-106.jpg"); 12 //建立数据的输入通道 13 FileInputStream fileInputStream = new FileInputStream(file); 14 //建立缓冲数组配合循环读取文件的数据。 15 int length = 0; //保存每次读取到的字节个数。 16 //存储读取到的数据 缓冲数组 的长度一般是1024的倍数，因为与计算机的处理单位。 理论上缓冲数组越大，效率越高 17 byte[] buf = new byte[1024]; 18 19 while((length = fileInputStream.read(buf))!=-1){ // read方法如果读取到了文件的末尾，那么会返回-1表示。 20 System.out.print(new String(buf,0,length)); 21 } 22 23 //关闭资源 24 fileInputStream.close(); 25 long endTime = System.currentTimeMillis(); 26 System.out.println("读取的时间是："+ (endTime-startTime)); //103 27 } 28 }
-
输出字节流：FileOutStream
--------| OutputStream 是所有输出字节流 的父类。 抽象类
-----------| FileOutStream 向文件输出数据的输出字节流。
FileOutputStream要注意的细节：
1. 使用FileOutputStream 的时候，如果目标文件不存在，那么会自动创建目标文件对象。
2. 使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。
3.使用FileOutputStream写数据的时候, 如果目标文件已经存在，需要在原来数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数，第二参数为true。
4.使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据，只是
把低八位的二进制数据写出，其他二十四位数据全部丢弃。
1 public class MyFileOutStream { 2 3 public static void main(String[] args) throws IOException { 4 writeTest3(); 5 } 6 7 8 //使用字节数组把数据写出。 9 public static void writeTest3() throws IOException{ 10 //找到目标文件 11 File file = new File("F:\\\\b.txt"); 12 //建立数据输出通道 13 FileOutputStream fileOutputStream = new FileOutputStream(file); 14 //把数据写出。 15 String data = "abc"; 16 byte[] buf = data.getBytes(); 17 fileOutputStream.write(buf, 0, 3); // 0 从字节数组的指定索引值开始写， 2：写出两个字节。 18 19 //关闭资源 20 fileOutputStream.close(); 21 } 22 }
- 输入字符流：FileReader
----------| Reader 输入字符流的基类 抽象类
-------------| FileReader 读取文件的输入字符流。
1 public class MyFileReader { 2 3 public static void main(String[] args) throws IOException { 4 readTest2(); 5 } 6 public static void readTest2() throws IOException{ 7 //找到目标文件 8 File file = new File("F:\\\\Demo1.java"); 9 // 建立数据的输入通道 10 @SuppressWarnings("resource") 11 FileReader fileReader = new FileReader(file); 12 //建立缓冲字符数组读取文件数据 13 char[] buf = new char[1024]; 14 int length = 0 ; 15 while((length = fileReader.read(buf))!=-1){ 16 System.out.print(new String(buf,0,length)); 17 } 18 fileReader.close(); 19 } 20 21 }
- 输出字符流：FileWriter
------| Writer 输出字符流的基类。 抽象类
-----------| FileWriter 向文件数据数据的输出字符流
FileWriter要注意的事项：
1. 使用FileWriter写数据的时候，FileWriter内部是维护了一个1024个字符数组的，写数据的时候会先写入到它内部维护的字符数组中，如果需要
把数据真正写到硬盘上，需要调用flush或者是close方法或者是填满了内部的字符数组。
2. 使用FileWriter的时候，如果目标文件不存在，那么会自动创建目标文件。
3.使用FileWriter的时候， 如果目标文件已经存在了，那么默认情况会先情况文件中的数据，然后再写入数据 ， 如果需要在原来的基础上追加数据，
需要使用“new FileWriter(File , boolean)”的构造方法，第二参数为true。
FileWriter- 缓冲输入字节流：BufferedInputStream
----| InputStream 输入字节流的基类。 抽象
----------| FileInputStream 读取文件数据的输入字节流
----------| BufferedInputStream 缓冲输入字节流 缓冲输入字节流的出现主要是为了提高读取文件数据的效率。
其实该类内部只不过是维护了一个8kb的字节数组而已。注意： 凡是缓冲流都不具备读写文件的能力。
BufferedInputStream- 缓冲输出字节流：Bufferedoutputstream
-------| OutputStream 所有输出字节流的基类 抽象类
------------| FileOutputStream 向文件 输出数据 的输出字节流
------------| Bufferedoutputstream 缓冲输出字节流 BufferedOutputStream出现的目的是为了提高写数据的效率。
内部也是维护了一个8kb的字节数组而已。
BufferedOutputStream 要注意的细节
1. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
2. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
调用flush方法或者是close方法、 或者是内部维护的字节数组已经填满数据的时候。
1 public class MyBufferedOutputStream { 2 3 public static void main(String[] args) throws IOException { 4 //找到目标文件 5 File file = new File("F:\\\\a.txt"); 6 //建立数据的输出通道 7 FileOutputStream fileOutputStream = new FileOutputStream(file); 8 //建立缓冲输出字节流对象 9 BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream); 10 //把数据写出 11 bufferedOutputStream.write("hello world".getBytes()); 12 //把缓冲数组中内部的数据写到硬盘上面。 13 //bufferedOutputStream.flush(); 14 bufferedOutputStream.close(); 15 } 16 17 }
- 缓冲输入字符流：BufferedReader
输入字符流:
-------| Reader 所有输入字符流的基类。 抽象类
----------| FileReader 读取文件字符串的输入字符流。
----------| BufferedReader 缓冲输入字符流 。 缓冲 输入字符流出现的目的是为了提高读取文件 的效率和拓展了FileReader的功能。 其实该类内部也是维护了一个字符数组 - 缓冲输出字符流：BufferedWriter
----------| Writer 所有输出字符流的基类， 抽象类。
--------------- | FileWriter 向文件输出字符数据的输出字符流。
----------------| BufferedWriter 缓冲输出字符流 缓冲输出字符流作用： 提高FileWriter的写数据效率与拓展FileWriter的功能。
BufferedWriter内部只不过是提供了一个8k长度的字符数组作为缓冲区而已，拓展了FileWriter的功能。 - 对象输出流：ObjectOutputStream
对象输入输出流要注意的细节：
1. 如果对象需要被写出到文件上，那么对象所属的类必须要实现Serializable接口。 Serializable接口没有任何的方法，是一个标识接口而已。
2. 对象的反序列化创建对象的时候并不会调用到构造方法的、
3. serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字。
4. 使用ObjectInputStream反序列化的时候，ObjeectInputStream会先读取文件中的serialVersionUID，然后与本地的class文件的serialVersionUID
进行对比，如果这两个id不一致，那么反序列化就失败了。
5. 如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后
在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。
6. 如果一个对象某个数据不想被序列化到硬盘上，可以使用关键字transient修饰。
7. 如果一个类维护了另外一个类的引用，那么另外一个类也需要实现Serializable接口。
1 class Address implements Serializable{ 2 3 private static final long serialVersionUID = 1L; 4 5 String country; 6 7 String city; 8 9 public Address(String country,String city){ 10 this.country = country; 11 this.city = city; 12 } 13 14 } 15 16 class User implements Serializable{ 17 18 private static final long serialVersionUID = 1L; 19 20 String userName ; 21 22 String password; 23 24 transient int age; // transient 透明 25 26 Address address ; 27 28 29 public User(String userName , String passwrod) { 30 this.userName = userName; 31 this.password = passwrod; 32 } 33 34 35 public User(String userName , String passwrod,int age,Address address) { 36 this.userName = userName; 37 this.password = passwrod; 38 this.age = age; 39 this.address = address; 40 } 41 42 @Override 43 public String toString() { 44 return "用户名："+this.userName+ " 密码："+ this.password+" 年龄："+this.age+" 地址："+this.address.city; 45 } 46 } 47 public class ObjectOutputStream1 { 48 49 public static void main(String[] args) throws IOException, Exception { 50 writeObj(); 51 // readObj(); 52 } 53 54 //把文件中的对象信息读取出来-------->对象的反序列化 55 public static void readObj() throws IOException, ClassNotFoundException{ 56 //找到目标文件 57 File file = new File("F:\\\\obj.txt"); 58 //建立数据的输入通道 59 FileInputStream fileInputStream = new FileInputStream(file); 60 //建立对象的输入流对象 61 ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream); 62 //读取对象信息 63 User user = (User) objectInputStream.readObject(); //创建对象肯定要依赖对象所属 的class文件。 64 System.out.println("对象的信息："+ user); 65 } 66 //定义方法把对象的信息写到硬盘上------>对象的序列化。 67 public static void writeObj() throws IOException{ 68 //把user对象的信息持久化存储。 69 Address address = new Address("中国","广州"); 70 User user = new User("admin","123",15,address); 71 //找到目标文件 72 File file = new File("F:\\\\obj.txt"); 73 //建立数据输出流对象 74 FileOutputStream fileOutputStream = new FileOutputStream(file); 75 //建立对象的输出流对象 76 ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream); 77 //把对象写出 78 objectOutputStream.writeObject(user); 79 //关闭资源 80 objectOutputStream.close(); 81 82 83 } 84 }
- 序列流：SequenceInputStream
1 /* 2 3 需求： 把一首mp3先切割成n份，然后再把这些文件合并起来。 4 5 */ 6 public class SequenceInputStream2 { 7 8 public static void main(String[] args) throws IOException { 9 // cutFile(); 10 mergeFlile(); 11 } 12 13 //合并 14 public static void mergeFlile() throws IOException{ 15 //找到目标文件 16 File dir = new File("F:\\\\music"); 17 //通过目标文件夹找到所有的MP3文件，然后把所有的MP3文件添加到vector中。 18 Vector<FileInputStream> vector = new Vector<FileInputStream>(); 19 File[] files = dir.listFiles(); 20 for(File file : files){ 21 if(file.getName().endsWith(".mp3")){ 22 vector.add(new FileInputStream(file)); 23 } 24 } 25 //通过Vector获取迭代器 26 Enumeration<FileInputStream> e = vector.elements(); 27 //创建序列流 28 SequenceInputStream inputStream = new SequenceInputStream(e); 29 //建立文件的输出通道 30 FileOutputStream fileOutputStream = new FileOutputStream("F:\\\\合并.mp3"); 31 //建立缓冲数组读取文件 32 byte[] buf = new byte[1024]; 33 int length = 0 ; 34 while((length = inputStream.read(buf))!=-1){ 35 fileOutputStream.write(buf,0,length); 36 } 37 //关闭资源 38 fileOutputStream.close(); 39 inputStream.close(); 40 41 } 42 43 //切割MP3 44 public static void cutFile() throws IOException{ 45 File file = new File("F:\\\\美女\\\\1.mp3"); 46 //目标文件夹 47 File dir = new File("F:\\\\music"); 48 //建立数据的输入通道 49 FileInputStream fileInputStream = new FileInputStream(file); 50 //建立缓冲数组读取 51 byte[] buf = new byte[1024*1024]; 52 int length = 0; 53 for(int i = 0 ; (length = fileInputStream.read(buf))!=-1 ; i++){ 54 FileOutputStream fileOutputStream = new FileOutputStream(new File(dir,"part"+i+".mp3")); 55 fileOutputStream.write(buf,0,length); 56 fileOutputStream.close(); 57 } 58 //关闭资源 59 fileInputStream.close(); 60 } 61 62 }
以上是关于java程序中的流都要统统关闭吗？有没有先后顺序？？的主要内容，如果未能解决你的问题，请参考以下文章