-
2022-04-29 16:37:33
在写Java输入输出流的时候很重要的一点就是在最后不要忘记调用close函数来关闭打开的流,因为打开文件是一种独占式的操作,打开后不关闭会导致其他程序不能再次打开这个文件。
为了避免程序员在写输入输出流时忘记关闭流,Java1.8之后提供了一种try的语法结构,可以实现流的自动关闭。其语法结构如下:
try (XSSFWorkbook xssfWorkbook = new XSSFWorkbook(new FileInputStream(stTemplate)); SXSSFWorkbook wb = new SXSSFWorkbook(xssfWorkbook)) { }
这回不管有无异常,都会给他自动关闭流!
更多相关内容 -
java中自动关流的新方式
2021-02-12 12:50:31但值的高兴的是,在jdk1.7以后就不用关流了,流会自动关闭,,这样一来,我们就不用担心关流的问题了。就在刚出版的jdk1.9中又对jdk1.7中的方式又做新的更新,先不急了解新写法,我们先从jdk1.7之前出现,看看之前关...前言
在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
-
Java解除文件占用即Dom4j操作后实现xml关流
2020-08-19 09:09:45主要介绍了Java解除文件占用即Dom4j操作后实现xml关流,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 -
【Java基础-3】吃透Java IO:字节流、字符流、缓冲流
2020-09-23 20:12:33什么是Java-IO?字符流和字节流的区别与适用场景是什么?缓冲流到底实现了什么?如何高效地读写文件? 本文用大量的示例图和实例,带你吃透Java IO。Java IO流
前言
有人曾问fastjson的作者(阿里技术专家高铁):“你开发fastjson,没得到什么好处,反而挨了骂背了锅,这种事情你为什么要做呢?”
高铁答道:“因为热爱本身,就是奖励啊!”
这个回答顿时触动了我。想想自己,又何尝不是如此。写作是个痛苦的过程,用心写作就更加煎熬,需字字斟酌,反复删改才有所成。然而,当一篇篇精良文章出自己手而呈现眼前时,那些痛苦煎熬就都那么值得。如果这些博文能有幸得大家阅读和认可,就更加是莫大的鼓舞了。技术人的快乐就是可以这么纯粹和简单。
点波关注不迷路,一键三连好运连连!
IO流是Java中的一个重要构成部分,也是我们经常打交道的。这篇关于Java IO的博文干货满满,堪称全网前三(请轻喷!)
下面几个问题(问题还会继续补充),如果你能对答如流,那么恭喜你,IO知识掌握得很好,可以立即关闭文章。反之,你可以在后面得文章中寻找答案。
- Java IO流有什么特点?
- Java IO流分为几种类型?
- 字节流和字符流的关系与区别?
- 字符流是否使用了缓冲?
- 缓冲流的效率一定高吗?为什么?
- 缓冲流体现了Java中的哪种设计模式思想?
- 为什么要实现序列化?如何实现序列化?
- 序列化数据后,再次修改类文件,读取数据会出问题,如何解决呢?
1 初识Java IO
IO,即
in
和out
,也就是输入和输出,指应用程序和外部设备之间的数据传递,常见的外部设备包括文件、管道、网络连接。Java 中是通过流处理IO 的,那么什么是流?
流(
Stream
),是一个抽象的概念,是指一连串的数据(字符或字节),是以先进先出的方式发送信息的通道。当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。
一般来说关于流的特性有下面几点:
- 先进先出:最先写入输出流的数据最先被输入流读取到。
- 顺序存取:可以一个接一个地往流中写入一串字节,读出时也将按写入顺序读取一串字节,不能随机访问中间的数据。(
RandomAccessFile
除外) - 只读或只写:每个流只能是输入流或输出流的一种,不能同时具备两个功能,输入流只能进行读操作,对输出流只能进行写操作。在一个数据传输通道中,如果既要写入数据,又要读取数据,则要分别提供两个流。
1.1 IO流分类
IO流主要的分类方式有以下3种:
- 按数据流的方向:输入流、输出流
- 按处理数据单位:字节流、字符流
- 按功能:节点流、处理流
1、输入流与输出流
输入与输出是相对于应用程序而言的,比如文件读写,读取文件是输入流,写文件是输出流,这点很容易搞反。
2、字节流与字符流字节流和字符流的用法几乎完成全一样,区别在于字节流和字符流所操作的数据单元不同,字节流操作的单元是数据单元是8位的字节,字符流操作的是数据单元为16位的字符。
为什么要有字符流?
Java中字符是采用Unicode标准,Unicode 编码中,一个英文字母或一个中文汉字为两个字节。
而在UTF-8编码中,一个中文字符是3个字节。例如下面图中,“云深不知处”5个中文对应的是15个字节:-28-70-111-26-73-79-28-72-115-25-97-91-27-92-124
那么问题来了,如果使用字节流处理中文,如果一次读写一个字符对应的字节数就不会有问题,一旦将一个字符对应的字节分裂开来,就会出现乱码了。为了更方便地处理中文这些字符,Java就推出了字符流。
字节流和字符流的其他区别:
- 字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件,如TXT文件等,但不能处理图像视频等非文本文件。用一句话说就是:字节流可以处理一切文件,而字符流只能处理纯文本文件。
- 字节流本身没有缓冲区,缓冲字节流相对于字节流,效率提升非常高。而字符流本身就带有缓冲区,缓冲字符流相对于字符流效率提升就不是那么大了。详见文末效率对比。
以写文件为例,我们查看字符流的源码,发现确实有利用到缓冲区:
3、节点流和处理流
节点流:直接操作数据读写的流类,比如
FileInputStream
处理流:对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能,例如
BufferedInputStream
(缓冲字节流)处理流和节点流应用了Java的装饰者设计模式。
下图就很形象地描绘了节点流和处理流,处理流是对节点流的封装,最终的数据处理还是由节点流完成的。
在诸多处理流中,有一个非常重要,那就是缓冲流。我们知道,程序与磁盘的交互相对于内存运算是很慢的,容易成为程序的性能瓶颈。减少程序与磁盘的交互,是提升程序效率一种有效手段。缓冲流,就应用这种思路:普通流每次读写一个字节,而缓冲流在内存中设置一个缓存区,缓冲区先存储足够的待操作数据后,再与内存或磁盘进行交互。这样,在总数据量不变的情况下,通过提高每次交互的数据量,减少了交互次数。
联想一下生活中的例子,我们搬砖的时候,一块一块地往车上装肯定是很低效的。我们可以使用一个小推车,先把砖装到小推车上,再把这小推车推到车前,把砖装到车上。这个例子中,小推车可以视为缓冲区,小推车的存在,减少了我们装车次数,从而提高了效率。
需要注意的是,缓冲流效率一定高吗?不一定,某些情形下,缓冲流效率反而更低,具体请见IO流效率对比。完整的IO分类图如下:
1.2 案例实操
接下来,我们看看如何使用Java IO。
文本读写的例子,也就是文章开头所说的,将“松下问童子,言师采药去。只在此山中,云深不知处。”写入本地文本,然后再从文件读取内容并输出到控制台。
1、FileInputStream、FileOutputStream(字节流)
字节流的方式效率较低,不建议使用
public class IOTest { public static void main(String[] args) throws IOException { File file = new File("D:/test.txt"); write(file); System.out.println(read(file)); } public static void write(File file) throws IOException { OutputStream os = new FileOutputStream(file, true); // 要写入的字符串 String string = "松下问童子,言师采药去。只在此山中,云深不知处。"; // 写入文件 os.write(string.getBytes()); // 关闭流 os.close(); } public static String read(File file) throws IOException { InputStream in = new FileInputStream(file); // 一次性取多少个字节 byte[] bytes = new byte[1024]; // 用来接收读取的字节数组 StringBuilder sb = new StringBuilder(); // 读取到的字节数组长度,为-1时表示没有数据 int length = 0; // 循环取数据 while ((length = in.read(bytes)) != -1) { // 将读取的内容转换成字符串 sb.append(new String(bytes, 0, length)); } // 关闭流 in.close(); return sb.toString(); } }
2、BufferedInputStream、BufferedOutputStream(缓冲字节流)
缓冲字节流是为高效率而设计的,真正的读写操作还是靠
FileOutputStream
和FileInputStream
,所以其构造方法入参是这两个类的对象也就不奇怪了。public class IOTest { public static void write(File file) throws IOException { // 缓冲字节流,提高了效率 BufferedOutputStream bis = new BufferedOutputStream(new FileOutputStream(file, true)); // 要写入的字符串 String string = "松下问童子,言师采药去。只在此山中,云深不知处。"; // 写入文件 bis.write(string.getBytes()); // 关闭流 bis.close(); } public static String read(File file) throws IOException { BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file)); // 一次性取多少个字节 byte[] bytes = new byte[1024]; // 用来接收读取的字节数组 StringBuilder sb = new StringBuilder(); // 读取到的字节数组长度,为-1时表示没有数据 int length = 0; // 循环取数据 while ((length = fis.read(bytes)) != -1) { // 将读取的内容转换成字符串 sb.append(new String(bytes, 0, length)); } // 关闭流 fis.close(); return sb.toString(); } }
3、InputStreamReader、OutputStreamWriter(字符流)
字符流适用于文本文件的读写,
OutputStreamWriter
类其实也是借助FileOutputStream
类实现的,故其构造方法是FileOutputStream
的对象public class IOTest { public static void write(File file) throws IOException { // OutputStreamWriter可以显示指定字符集,否则使用默认字符集 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8"); // 要写入的字符串 String string = "松下问童子,言师采药去。只在此山中,云深不知处。"; osw.write(string); osw.close(); } public static String read(File file) throws IOException { InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "UTF-8"); // 字符数组:一次读取多少个字符 char[] chars = new char[1024]; // 每次读取的字符数组先append到StringBuilder中 StringBuilder sb = new StringBuilder(); // 读取到的字符数组长度,为-1时表示没有数据 int length; // 循环取数据 while ((length = isr.read(chars)) != -1) { // 将读取的内容转换成字符串 sb.append(chars, 0, length); } // 关闭流 isr.close(); return sb.toString() } }
4、字符流便捷类
Java提供了
FileWriter
和FileReader
简化字符流的读写,new FileWriter
等同于new OutputStreamWriter(new FileOutputStream(file, true))
public class IOTest { public static void write(File file) throws IOException { FileWriter fw = new FileWriter(file, true); // 要写入的字符串 String string = "松下问童子,言师采药去。只在此山中,云深不知处。"; fw.write(string); fw.close(); } public static String read(File file) throws IOException { FileReader fr = new FileReader(file); // 一次性取多少个字节 char[] chars = new char[1024]; // 用来接收读取的字节数组 StringBuilder sb = new StringBuilder(); // 读取到的字节数组长度,为-1时表示没有数据 int length; // 循环取数据 while ((length = fr.read(chars)) != -1) { // 将读取的内容转换成字符串 sb.append(chars, 0, length); } // 关闭流 fr.close(); return sb.toString(); } }
5、BufferedReader、BufferedWriter(字符缓冲流)
public class IOTest { public static void write(File file) throws IOException { // BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new // FileOutputStream(file, true), "UTF-8")); // FileWriter可以大幅度简化代码 BufferedWriter bw = new BufferedWriter(new FileWriter(file, true)); // 要写入的字符串 String string = "松下问童子,言师采药去。只在此山中,云深不知处。"; bw.write(string); bw.close(); } public static String read(File file) throws IOException { BufferedReader br = new BufferedReader(new FileReader(file)); // 用来接收读取的字节数组 StringBuilder sb = new StringBuilder(); // 按行读数据 String line; // 循环取数据 while ((line = br.readLine()) != null) { // 将读取的内容转换成字符串 sb.append(line); } // 关闭流 br.close(); return sb.toString(); } }
2 IO流对象
第一节中,我们大致了解了IO,并完成了几个案例,但对IO还缺乏更详细的认知,那么接下来我们就对Java IO细细分解,梳理出完整的知识体系来。
Java种提供了40多个类,我们只需要详细了解一下其中比较重要的就可以满足日常应用了。
2.1 File类
File
类是用来操作文件的类,但它不能操作文件中的数据。public class File extends Object implements Serializable, Comparable<File>
File
类实现了Serializable
、Comparable<File>
,说明它是支持序列化和排序的。File类的构造方法
方法名 说明 File(File parent, String child)
根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。 File(URI uri)
通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。 File类的常用方法
方法 说明 createNewFile()
当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。 delete()
删除此抽象路径名表示的文件或目录。 exists()
测试此抽象路径名表示的文件或目录是否存在。 getAbsoluteFile()
返回此抽象路径名的绝对路径名形式。 getAbsolutePath()
返回此抽象路径名的绝对路径名字符串。 length()
返回由此抽象路径名表示的文件的长度。 mkdir()
创建此抽象路径名指定的目录。 File类使用实例
public class FileTest { public static void main(String[] args) throws IOException { File file = new File("C:/Mu/fileTest.txt"); // 判断文件是否存在 if (!file.exists()) { // 不存在则创建 file.createNewFile(); } System.out.println("文件的绝对路径:" + file.getAbsolutePath()); System.out.println("文件的大小:" + file.length()); // 刪除文件 file.delete(); } }
2.2 字节流
InputStream
与OutputStream
是两个抽象类,是字节流的基类,所有具体的字节流实现类都是分别继承了这两个类。以
InputStream
为例,它继承了Object
,实现了Closeable
public abstract class InputStream extends Object implements Closeable
InputStream
类有很多的实现子类,下面列举了一些比较常用的:
详细说明一下上图中的类:InputStream
:InputStream
是所有字节输入流的抽象基类,前面说过抽象类不能被实例化,实际上是作为模板而存在的,为所有实现类定义了处理输入流的方法。FileInputSream
:文件输入流,一个非常重要的字节输入流,用于对文件进行读取操作。PipedInputStream
:管道字节输入流,能实现多线程间的管道通信。ByteArrayInputStream
:字节数组输入流,从字节数组(byte[])中进行以字节为单位的读取,也就是将资源文件都以字节的形式存入到该类中的字节数组中去。FilterInputStream
:装饰者类,具体的装饰者继承该类,这些类都是处理类,作用是对节点类进行封装,实现一些特殊功能。DataInputStream
:数据输入流,它是用来装饰其它输入流,作用是“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。BufferedInputStream
:缓冲流,对节点流进行装饰,内部会有一个缓存区,用来存放字节,每次都是将缓存区存满然后发送,而不是一个字节或两个字节这样发送,效率更高。ObjectInputStream
:对象输入流,用来提供对基本数据或对象的持久存储。通俗点说,也就是能直接传输对象,通常应用在反序列化中。它也是一种处理流,构造器的入参是一个InputStream
的实例对象。
OutputStream
类继承关系图:
OutputStream
类继承关系与InputStream
类似,需要注意的是PrintStream
.2.3 字符流
与字节流类似,字符流也有两个抽象基类,分别是
Reader
和Writer
。其他的字符流实现类都是继承了这两个类。以
Reader
为例,它的主要实现子类如下图:
各个类的详细说明:InputStreamReader
:从字节流到字符流的桥梁(InputStreamReader
构造器入参是FileInputStream
的实例对象),它读取字节并使用指定的字符集将其解码为字符。它使用的字符集可以通过名称指定,也可以显式给定,或者可以接受平台的默认字符集。BufferedReader
:从字符输入流中读取文本,设置一个缓冲区来提高效率。BufferedReader
是对InputStreamReader
的封装,前者构造器的入参就是后者的一个实例对象。FileReader
:用于读取字符文件的便利类,new FileReader(File file)
等同于new InputStreamReader(new FileInputStream(file, true),"UTF-8")
,但FileReader
不能指定字符编码和默认字节缓冲区大小。PipedReader
:管道字符输入流。实现多线程间的管道通信。CharArrayReader
:从Char
数组中读取数据的介质流。StringReader
:从String
中读取数据的介质流。
Writer
与Reader
结构类似,方向相反,不再赘述。唯一有区别的是,Writer
的子类PrintWriter
。2.4 序列化
待续…
3 IO流方法
3.1 字节流方法
字节输入流
InputStream
主要方法:read()
:从此输入流中读取一个数据字节。read(byte[] b)
:从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。read(byte[] b, int off, int len)
:从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。close()
:关闭此输入流并释放与该流关联的所有系统资源。
字节输出流
OutputStream
主要方法:write(byte[] b)
:将 b.length 个字节从指定 byte 数组写入此文件输出流中。write(byte[] b, int off, int len)
:将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。write(int b)
:将指定字节写入此文件输出流。close()
:关闭此输入流并释放与该流关联的所有系统资源。
3.2 字符流方法
字符输入流
Reader
主要方法:read()
:读取单个字符。read(char[] cbuf)
:将字符读入数组。read(char[] cbuf, int off, int len)
: 将字符读入数组的某一部分。read(CharBuffer target)
:试图将字符读入指定的字符缓冲区。flush()
:刷新该流的缓冲。close()
:关闭此流,但要先刷新它。
字符输出流
Writer
主要方法:write(char[] cbuf)
:写入字符数组。write(char[] cbuf, int off, int len)
:写入字符数组的某一部分。write(int c)
:写入单个字符。write(String str)
:写入字符串。write(String str, int off, int len)
:写入字符串的某一部分。flush()
:刷新该流的缓冲。close()
:关闭此流,但要先刷新它。
另外,字符缓冲流还有两个独特的方法:
BufferedWriter
类newLine()
:写入一个行分隔符。这个方法会自动适配所在系统的行分隔符。BufferedReader
类readLine()
:读取一个文本行。
4 附加内容
4.1 位、字节、字符
字节(Byte)是计量单位,表示数据量多少,是计算机信息技术用于计量存储容量的一种计量单位,通常情况下一字节等于八位。
字符(Character)计算机中使用的字母、数字、字和符号,比如’A’、‘B’、’$’、’&'等。
一般在英文状态下一个字母或字符占用一个字节,一个汉字用两个字节表示。
字节与字符:
- ASCII 码中,一个英文字母(不分大小写)为一个字节,一个中文汉字为两个字节。
- UTF-8 编码中,一个英文字为一个字节,一个中文为三个字节。
- Unicode 编码中,一个英文为一个字节,一个中文为两个字节。
- 符号:英文标点为一个字节,中文标点为两个字节。例如:英文句号 . 占1个字节的大小,中文句号 。占2个字节的大小。
- UTF-16 编码中,一个英文字母字符或一个汉字字符存储都需要 2 个字节(Unicode 扩展区的一些汉字存储需要 4 个字节)。
- UTF-32 编码中,世界上任何字符的存储都需要 4 个字节。
4.2 IO流效率对比
首先,对比下普通字节流和缓冲字节流的效率:
public class MyTest { public static void main(String[] args) throws IOException { File file = new File("C:/Mu/test.txt"); StringBuilder sb = new StringBuilder(); for (int i = 0; i < 3000000; i++) { sb.append("abcdefghigklmnopqrstuvwsyz"); } byte[] bytes = sb.toString().getBytes(); long start = System.currentTimeMillis(); write(file, bytes); long end = System.currentTimeMillis(); long start2 = System.currentTimeMillis(); bufferedWrite(file, bytes); long end2 = System.currentTimeMillis(); System.out.println("普通字节流耗时:" + (end - start) + " ms"); System.out.println("缓冲字节流耗时:" + (end2 - start2) + " ms"); } // 普通字节流 public static void write(File file, byte[] bytes) throws IOException { OutputStream os = new FileOutputStream(file); os.write(bytes); os.close(); } // 缓冲字节流 public static void bufferedWrite(File file, byte[] bytes) throws IOException { BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(file)); bo.write(bytes); bo.close(); } }
运行结果:
普通字节流耗时:250 ms 缓冲字节流耗时:268 ms
这个结果让我大跌眼镜,不是说好缓冲流效率很高么?要知道为什么,只能去源码里找答案了。翻看字节缓冲流的
write
方法:public synchronized void write(byte b[], int off, int len) throws IOException { if (len >= buf.length) { /* If the request length exceeds the size of the output buffer, flush the output buffer and then write the data directly. In this way buffered streams will cascade harmlessly. */ flushBuffer(); out.write(b, off, len); return; } if (len > buf.length - count) { flushBuffer(); } System.arraycopy(b, off, buf, count, len); count += len; }
注释里说得很明白:如果请求长度超过输出缓冲区的大小,刷新输出缓冲区,然后直接写入数据。这样,缓冲流将无害地级联。
但是,至于为什么这么设计,我没有想明白,有哪位明白的大佬可以留言指点一下。
基于上面的情形,要想对比普通字节流和缓冲字节流的效率差距,就要避免直接读写较长的字符串,于是,设计了下面这个对比案例:用字节流和缓冲字节流分别复制文件。
public class MyTest { public static void main(String[] args) throws IOException { File data = new File("C:/Mu/data.zip"); File a = new File("C:/Mu/a.zip"); File b = new File("C:/Mu/b.zip"); StringBuilder sb = new StringBuilder(); long start = System.currentTimeMillis(); copy(data, a); long end = System.currentTimeMillis(); long start2 = System.currentTimeMillis(); bufferedCopy(data, b); long end2 = System.currentTimeMillis(); System.out.println("普通字节流耗时:" + (end - start) + " ms"); System.out.println("缓冲字节流耗时:" + (end2 - start2) + " ms"); } // 普通字节流 public static void copy(File in, File out) throws IOException { // 封装数据源 InputStream is = new FileInputStream(in); // 封装目的地 OutputStream os = new FileOutputStream(out); int by = 0; while ((by = is.read()) != -1) { os.write(by); } is.close(); os.close(); } // 缓冲字节流 public static void bufferedCopy(File in, File out) throws IOException { // 封装数据源 BufferedInputStream bi = new BufferedInputStream(new FileInputStream(in)); // 封装目的地 BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(out)); int by = 0; while ((by = bi.read()) != -1) { bo.write(by); } bo.close(); bi.close(); } }
运行结果:
普通字节流耗时:184867 ms 缓冲字节流耗时:752 ms
这次,普通字节流和缓冲字节流的效率差异就很明显了,达到了245倍。
再看看字符流和缓冲字符流的效率对比:
public class IOTest { public static void main(String[] args) throws IOException { // 数据准备 dataReady(); File data = new File("C:/Mu/data.txt"); File a = new File("C:/Mu/a.txt"); File b = new File("C:/Mu/b.txt"); File c = new File("C:/Mu/c.txt"); long start = System.currentTimeMillis(); copy(data, a); long end = System.currentTimeMillis(); long start2 = System.currentTimeMillis(); copyChars(data, b); long end2 = System.currentTimeMillis(); long start3 = System.currentTimeMillis(); bufferedCopy(data, c); long end3 = System.currentTimeMillis(); System.out.println("普通字节流1耗时:" + (end - start) + " ms,文件大小:" + a.length() / 1024 + " kb"); System.out.println("普通字节流2耗时:" + (end2 - start2) + " ms,文件大小:" + b.length() / 1024 + " kb"); System.out.println("缓冲字节流耗时:" + (end3 - start3) + " ms,文件大小:" + c.length() / 1024 + " kb"); } // 普通字符流不使用数组 public static void copy(File in, File out) throws IOException { Reader reader = new FileReader(in); Writer writer = new FileWriter(out); int ch = 0; while ((ch = reader.read()) != -1) { writer.write((char) ch); } reader.close(); writer.close(); } // 普通字符流使用字符流 public static void copyChars(File in, File out) throws IOException { Reader reader = new FileReader(in); Writer writer = new FileWriter(out); char[] chs = new char[1024]; while ((reader.read(chs)) != -1) { writer.write(chs); } reader.close(); writer.close(); } // 缓冲字符流 public static void bufferedCopy(File in, File out) throws IOException { BufferedReader br = new BufferedReader(new FileReader(in)); BufferedWriter bw = new BufferedWriter(new FileWriter(out)); String line = null; while ((line = br.readLine()) != null) { bw.write(line); bw.newLine(); bw.flush(); } // 释放资源 bw.close(); br.close(); } // 数据准备 public static void dataReady() throws IOException { StringBuilder sb = new StringBuilder(); for (int i = 0; i < 600000; i++) { sb.append("abcdefghijklmnopqrstuvwxyz"); } OutputStream os = new FileOutputStream(new File("C:/Mu/data.txt")); os.write(sb.toString().getBytes()); os.close(); System.out.println("完毕"); } }
运行结果:
普通字符流1耗时:1337 ms,文件大小:15234 kb 普通字符流2耗时:82 ms,文件大小:15235 kb 缓冲字符流耗时:205 ms,文件大小:15234 kb
测试多次,结果差不多,可见字符缓冲流效率上并没有明显提高,我们更多的是要使用它的
readLine()
和newLine()
方法。4.3 NIO
待续…
-
JAVA_IO流的关闭两种方式
2022-03-21 20:19:40流的关闭 当使用完流后,显示的关闭所有打开的流仍然是一个好习惯。一个被打开的流有可能会用尽系统的资源,这取决于平台和实现。如果没有将流关闭,另一个程序试图打开另一个流时,可能会得到不需要的资源。 从JDK...流的关闭
当使用完流后,显示的关闭所有打开的流仍然是一个好习惯。一个被打开的流有可能会用尽系统的资源,这取决于平台和实现。如果没有将流关闭,另一个程序试图打开另一个流时,可能会得到不需要的资源。从JDK1.7后,有两种关闭数据流的方法,分别如下:
方法一:手动关闭。即为使用close()显式地关闭流,代码如下package com.qfstu.Week04.Day01; import java.io.FileInputStream; import java.io.IOException; /** * @Author bolin * @Description TODO * @Date 2022/3/21 19:34 * @Version 1.0 */ public class TestFileInputStream01 { public static void main(String[] args) { //注意:此处需要提前声明局部变量 并初始化为空 //否则下方的 finally处无法使用fis.close关闭流 FileInputStream fis = null; try { fis = new FileInputStream("D:\\Test01.txt"); //此处可以实现对流的操作 此处省略 //此处默认会生成IOException、FileNotFoundException等异常 较为繁琐 //可以直接捕捉父类异常 Exception } catch (Exception e) { //打印异常信息 e.printStackTrace(); //由于finally一定执行 故将关闭流操作放到finally语句块中 } finally { //如果文件输入流不是null 关闭流 if(fis != null) { try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } } } }
方法二:自动关闭。即为使用try语句自动关闭流,代码如下:
package com.qfstu.Week04.Day01; import java.io.FileInputStream; /** * @Author 25741 * @Description TODO * @Date 2022/3/21 19:40 * @Version 1.0 */ public class TestFileInputStream02 { public static void main(String[] args) { //直接在try()中创建流对象 会默认关闭 try (FileInputStream fis = new FileInputStream("D:\\Test01.txt")) { //读写操作 此处省略 //详细解释见上面代码块 }catch(Exception e) { e.printStackTrace(); } } }
注:使用IDEA书写代码时,使用快捷键 alt+enter 处理异常时经常遇到如下选项:
四个选项中此处只介绍一种抛出异常和两种捕捉异常
* 选项1、Add... ... 代表抛出异常 选择使用throws抛出异常时候则必须close()方法关闭流 * 选项2、Surround... ... 代表生成 try{ //语句 }catch (Exception e) { //打印异常信息 e.printStackTrace(); } finally{ //关闭流 } * 选项4、Surround... ...代表生成 try(//语句) { //语句 }catch(Exception e) { //打印异常信息 e.printStackTrace(); } 注:try()其中的括号内生成的流对象会默认自动关闭 便是方法二中使用的
-
Java 8 Stream 流已被操作或关闭
2021-03-15 18:19:01在Java 8中,Stream不能重复使用,一旦被消耗或使用,流将被关闭,类似流水线,水龙头的水一样一去不复返示例 – 流关闭查看以下示例,它会抛出一个IllegalStateException,表示“流被关闭”。TestJava8.javapackage... -
JAVA中如何优雅的关闭各种流
2021-02-28 16:06:31在JAVA 中我们会遇到各种流,每次写的时候我们需要在finally方法中关闭流,在关闭之前我们还要判断流是否为null,很麻烦!原来的写法:(向TXT中写入内容)public void testOne() {File writeName = new File("output.... -
Java流关闭总结
2021-02-12 22:34:27由Java.io包中的对象生成实例的close方法使用情况BufferedInputStream bis = new BufferedInputStream(new InputStreamReader(new FileInputStream()))BufferedInputStream类public voidclose()throwsIOException{b.... -
使用try-with-resource自动关流
2020-04-03 11:29:35使用try-with-resource自动关流 ```java try(BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:/img/a.jpg")); BufferedOutputStream bos= new BufferedOutputStream(new ... -
Java之关闭流
2014-08-13 18:23:43我们深知在操作Java流对象后要将流关闭,但往往事情不尽人意,大致有以下几种不能一定将流关闭的写法: 1.在try中关流,而没在finally中关流 try { OutputStream out = new FileOutputStream(""); // ...操作流... -
java并行流
2019-08-13 15:55:58在java7之前,处理并行数据非常麻烦. 第一:你得明确的把包含的数据结构分成若干子部分. 第二:你要给每个子部分分配独立的线程. 第三:你需要在恰当的时候对他们进行同步,来避免不希望出现的竞争条件,等待所有线程完成,... -
jdk1.7新特性: 自动关闭IO流
2018-12-20 10:08:55jdk1.7版本起,可以自动关闭IO流 如:获取一个文件内容,以前通常是这样写: /** * 获取文件内容 * @param file 文件 * @return 内容 */ public String getText(File file){ FileInputStream fis = null; ... -
java8学习第二篇:try-with-resources
2021-03-13 09:29:51Java8里的一个新语法特性:try-...try-with-resources的特性就是,在try( …)里声明的资源,会在try-catch代码块结束后自动关闭掉。废话不说,先上代码后分析。public class AutoCloseTest {public static void main... -
Java-IO 流的Close方法
2019-10-24 14:15:31一、在Java中为何要关闭流 GC运行的时间点是不确定的(因为是一条单独存在的线程),所以很多时候你不能直接控制什么时候发生GC。这个带来的问题有两点,一个是有时候你的内存不足需要立刻回收而GC并不会立刻运行;... -
Java IO 关闭流的方式
2019-07-26 10:35:49Java IO 关闭流的方式分类练习:把[拆分文件中的关闭流方式改为finally形式](https://blog.csdn.net/renweiyi1487/article/details/97253192)练习把[文件合并中的流关闭方式改为try()形式]...这里更详细... -
JAVA IO 字节流 字符流 高效缓冲流 close()flush()区别
2020-07-18 19:13:12IO 字节流 字符流 高效缓冲流 close()flush()区别 这篇也是纯课堂笔记,没做什么总结和编辑,都是理解性的内容,直接流的概念和怎么用就行 IO input和output 输入和输出, 用于设备与设备进行交互,数据从其他设备... -
JAVA实现闯关小游戏(一)
2022-04-20 21:36:08(一)游戏设计思路: 如图为游戏效果演示: ...此游戏为闯关游戏,类似于超级玛丽,但更加自由一些;画面采用后现代主义抽象风格,音乐采用的星露谷物语里的专辑,有竖琴演奏; 游戏框架: 1.继承JFrame创建窗口: -
如何通过try-catch自动实现IO流的关闭
2021-02-09 10:06:41如何通过try-catch自动实现IO流的关闭 在jdk1.7版本中通过在try后增加一个()在()中创建IO流的对象,默认就会 在我们学习的常用的异常处理中,语法为 try{ }catch(Exception e){ } 而该方法无法实现IO流的错误分离。... -
使用try语句自动关闭流
2019-05-22 15:02:42虽然在java程序在结束时自动关闭所有打开的流,但是当使用完流后,显示的关闭所有打开的流仍然是一个好习惯。一个被打开的流有可能会用尽系统的资源,这取决于平台和实现。如果没有将流关闭,另一个程序试图打开另一... -
java文件流的关闭问题
2017-09-02 09:32:331. writer =new BufferedWriter(new ...可是第一个案例new OutputStreamWriter 这个new出来的流我没有实例化,这样写合理吗,还是说像第二个案例这样关闭三个流。第一种会不会造成流不关闭情况。有人晓得不。 -
JAVAIO流笔记
2022-03-13 20:42:36JavaIO流基础笔记 -
Java使用try(){}自动关闭资源
2019-12-26 14:17:36常见于流操作,socket操作,不用写一大堆finally来关闭资源,所有实现Closeable的类声明都可以写在里面 1、流操作的一般写法: public static void copyFileUsingFileStreams(File source, File dest) { ... -
Java中的File类和IO流
2019-08-19 20:40:381.File:翻译是文件,用于表达java中的路径名。 2.路径:用于表示文件或者文件夹在当前系统中的位置 3.路径的分类: 绝对路径 相对路径 4.绝对路径:没有任何的歧义,也没有任何的前提条件 Windows,从盘符开始的... -
Java学习笔记20:Java_字符流_转换流_对象操作流_Properties集合
2021-08-08 20:15:01由于字节流操作中文不是特别的方便,所以Java就提供字符流 字符流 = 字节流 + 编码表 中文的字节存储方式 用字节流复制文本文件时,文本文件也会有中文,但是没有问题,原因是最终底层操作会自动进行字节拼接成... -
关于java POI读取Excel2007流关不掉问题
2018-04-12 15:58:41使用java POI读取文件经常会发现流关不掉,导致源文件无法删除,令人头疼,网上基本上也找不到靠谱的解决方法。之前代码出错是这样的:第一种:InputStream inputStream=new FileInputStream(file);// (1) ... -
Java byte stream 字节流
2020-03-12 13:15:08本文介绍了 Java 中 byte stream(字节流)的相关内容。。。 -
JAVA上百实例源码以及开源项目源代码
2018-12-11 17:07:42Java目录监视器源程序 9个目标文件 内容索引:JAVA源码,综合应用,目录监视 用JAVA开发的一个小型的目录监视系统,系统会每5秒自动扫描一次需要监视的目录,可以用来监视目录中文件大小及文件增减数目的变化。 Java... -
为什么java io流必须得关闭
2021-01-04 11:12:43在内存中的实例对象,当没有引用指向的时候,java垃圾收集器会按照相应的策略自动回收,但是却无法对系统资源进行释放。所以,我们需要主动调用close()方法释放java流对象。在java7之后,可以使用try-with-resources...