Java IO流基础1--IO的分类体系与文件流
什么是IO流
Java中的IO
了解什么是IO流之前,要先知道什么是IO。IO,就是in和out(即输入和输出),指应用程序和外部设备之间的数据传递,常见的外部设备包括文件、管道、网络连接等。
流的概念与特性
概念
Java 中是通过流处理IO 的。流(Stream),是一个抽象的概念,是指一连串的数据(字符或字节),是以先进先出的方式发送信息的通道。当程序需要读取数据时,就会开启一个通向数据源的流,同理,当程序需要写入数据时,就会开启一个通向目的地的流。
特性
关于流的特性有以下几点:
- 先进先出:最先写入输出流的数据最先被输入流读取到。
- 顺序存取:可以一个接一个地往流中写入一串字节,读出时也将按写入顺序读取一串字节,不能随机访问中间的数据。(
RandomAccessFile
除外,它可以对文件随机访问的操作,访问包括读和写操作) - 只读或只写:每个流只能是输入流或输出流的一种,不能同时具备两个功能,输入流只能进行读操作,对输出流只能进行写操作。在一个数据传输通道中,如果既要写入数据,又要读取数据,则要分别提供两个流。
IO流的分类
IO分类图如下(详细内容可查看API文档):
IO流主要的分类方式有以下3种:
- 按数据流的方向:输入流、输出流
- 按处理数据单位:字节流、字符流
- 按功能:节点流、处理流
输入流与输出流
这里要注意的是:输入与输出是相对于应用程序而言的,比如文件读写,读取文件是输入流,写文件是输出流(即流向内存是输入流,流出内存的输出流),不要搞反,不是很清楚可以看下图。
字节流与字符流
Unicode 编码中,一个英文为1个字节,一个中文为2个字节。而在UTF-8编码中,一个中文字符是3个字节。如果使用字节流处理中文,如果一次读写一个字符对应的字节数就不会有问题,一旦将一个字符对应的字节分裂开来,就会出现乱码了。为了更方便地处理中文这些字符,Java就推出了字符流。
字节流和字符流的用法几乎完全一样,区别在于字节流和字符流所操作的数据单元不同,字节流操作的单元是数据单元是8位的字节(即1个字节),字符流操作的是数据单元为16位的字符(即1个字符或2个字节)。
字节流和字符流的其他区别:
- 字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件,如TXT文件等,但不能处理图像视频等非文本文件。简单说就是就是:字节流可以处理一切文件,而字符流只能处理纯文本文件。
- 字节流本身没有缓冲区,缓冲字节流相对于字节流,效率提升非常高。而字符流本身就带有缓冲区,缓冲字符流相对于字符流效率提升就不是那么大了。
节点流和处理流
- 节点流:直接操作数据读写的流类,比如
FileInputStream
- 处理流:对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能,例如
BufferedInputStream
(缓冲字节流)
处理流和节点流应用了Java的装饰者设计模式。下图就很形象地描绘了节点流和处理流,处理流是对节点流的封装,最终的数据处理还是由节点流完成的。
缓冲流:
在诸多处理流中,有一个非常重要,那就是缓冲流。程序与磁盘的交互相对于内存运算是很慢的,容易成为程序的性能瓶颈。减少程序与磁盘的交互,是提升程序效率一种有效手段。缓冲流,就应用这种思路:普通流每次读写一个字节,而缓冲流在内存中设置一个缓存区,缓冲区先存储足够的待操作数据后,再与内存或磁盘进行交互。这样,在总数据量不变的情况下,通过提高每次交互的数据量,减少了交互次数。需要注意的是,缓冲流效率不一定高,在某些情形下,缓冲流效率反而更低,具体请见IO流效率对比。
字节流
一切皆为字节
字节输出流【OutputStream】
- public void close() :关闭此输出流并释放与此流相关联的任何系统资源。
- public void flush() :刷新此输出流并强制任何缓冲的输出字节被写出。
- public void write(byte[] b) :将 b.length字节从指定的字节数组写入此输出流。
- public void write(byte[] b, int off, int len) :从指定的字节数组写入 len(长度)字节,从偏移量 off(索引)开始输出到此输出流。
- public abstract void write(int b) :将指定的字节输出流。
小贴士:
- close()方法,当完成流的操作时,必须调用此方法,释放系统资源。
- 在创建字节输出流对象和使用write()方法写出数据时,会分别抛出FileNotFoundException 和 IOException异常,要注意的是,IOException异常是FileNotFoundException异常的父类,所以这里我们直接抛出IOException异常就可以了。
FileOutputStream类
OutputStream 有很多子类,我们从最常见的一个类FileOutputStream类开始。java.io.FileOutputStream 类是文件输出流,用于将数据写出到文件。
构造方法
- public FileOutputStream(File file) :创建一个向指定File对象表示的文件中写入数据的文件输出流。
- public FileOutputStream(String name) : 创建一个向具有指定名称的文件中写入数据的输出文件流。
参数 File file:目的地是一个文件 String name:目的地是一个文件的路径
作用:
- 创建一个Fileoutputstream对象
- 会根据构造方法中传递的文件/文件路径,创建一个空的文件
- 会把FiLeOutputStream对象指向创建好的文件
构造方法代码演示:
public class FileOutputStreamConstructor throws IOException { public static void main(String[] args) { // 使用File对象创建流对象 File file = new File("a.txt"); FileOutputStream fos = new FileOutputStream(file); // 使用文件名称创建流对象 FileOutputStream fos = new FileOutputStream("b.txt"); } }
写出字节数据:
原理:(内存-->硬盘)
java程序-->JVM(java虚拟机 )-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中
方法:
- 写出字节: write(int b) 方法,每次可以写出一个字节数据,代码演示:
public class FOSWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 FileOutputStream fos = new FileOutputStream("fos.txt"); // 写出数据 fos.write(97);//写出第1个字节 fos.write(98);//写出第2个字节 fos.write(99);//写出第3个字节 // 关闭资源 fos.close(); } }
输出结果:
abc
- 写出字节数组: write(byte[] b) ,每次可以写出数组中的数据,代码演示:
public class FOSWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 FileOutputStream fos = new FileOutputStream("fos.txt"); // 字符串转换为字节数组 byte[] b = "张三李四王五".getBytes(); // 写出字节数组数据 fos.write(b); // 关闭资源 fos.close(); } } 输出结果: 张三李四王五
- 写出指定长度字节数组: write(byte[] b, int off, int len) ,每次写出从off索引开始,len个字节,代码演示:
public class FOSWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 FileOutputStream fos = new FileOutputStream("fos.txt"); // 字符串转换为字节数组 byte[] b = "abcde".getBytes(); // 写出从索引1开始,2个字节。索引1是b,两个字节,也就是bc。 fos.write(b,1,2); // 关闭资源 fos.close(); } } 输出结果: bc
数据追加续写
- public FileOutputStream(File file, boolean append) : 创建文件输出流以写入由指定的 File对象表示的文件。
- public FileOutputStream(String name, boolean append) : 创建文件输出流以指定的名称写入文件。
代码使用演示:
public class FOSWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象并设置数据追加续写 FileOutputStream fos = new FileOutputStream("fos.txt",true); // 字符串转换为字节数组 byte[] b = "abcde".getBytes(); // 写出字节数组数据 fos.write(b); // 关闭资源 fos.close(); } } 文件操作前: bc 文件操作后: bcabcde
写出换行
- Windows系统里,每行结尾是 回车+换行 ,即 \r\n ;
- Unix系统里,每行结尾只有 换行 ,即 \n ;
- Mac系统里,每行结尾是 回车 ,即 \r 。
代码使用演示:
public class FOSWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 FileOutputStream fos = new FileOutputStream("fos.txt"); // 定义字节数组 byte[] words = {97,98,99,100,101}; // 遍历数组 for (int i = 0; i < words.length; i++) { // 写出一个字节 fos.write(words[i]); // 写出一个换行, 换行符号转成数组写出 fos.write("\r\n".getBytes()); } // 关闭资源 fos.close(); } } 输出结果: a b c d e
字节输入流【InputStream】
- public void close() :关闭此输入流并释放与此流相关联的任何系统资源。
- public abstract int read() : 从输入流读取数据的下一个字节。
- public int read(byte[] b) : 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
小贴士:
- close方法,当完成流的操作时,必须调用此方法,释放系统资源。
- 在创建字节输入流对象和使用read()方法读取数据时,会分别抛出FileNotFoundException 和 IOException异常,要注意的是,IOException异常是FileNotFoundException异常的父类,所以这里我们直接抛出IOException异常就可以了。
FileInputStream类
构造方法
- FileInputStream(File file) : 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 fifile命名。
- FileInputStream(String name) : 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
参数:读取文件的数据源 File file:文件 String name:文件的路径
构造方法代码演示:
public class FileInputStreamConstructor throws IOException{ public static void main(String[] args) { // 使用File对象创建流对象 File file = new File("a.txt"); FileInputStream fis = new FileInputStream(file); // 使用文件名称创建流对象 FileInputStream fis = new FileInputStream("b.txt"); } }
作用:
- 会创建一个FileInputStream对象
- 会把FileInputstream对象指向构造方法中要读取的文件
读取字节数据
原理:(硬盘-->内存)
java程序-->JVM(java虚拟机 )-->OS(操作系统)-->OS调用读取数据的方法-->从文件中读取数据
方法:
- 读取字节: read():每次可以读取一个字节的数据,返回值int类型,读取到文件末尾,返回 -1 ,代码演示:
public class FISRead { public static void main(String[] args) throws IOException{ // 使用文件名称创建流对象,文件内容为abcde FileInputStream fis = new FileInputStream("read.txt"); // 读取数据,返回一个字节 int read = fis.read(); System.out.println((char) read); read = fis.read(); System.out.println((char) read); read = fis.read(); System.out.println((char) read); read = fis.read(); System.out.println((char) read); read = fis.read(); System.out.println((char) read); // 读取到末尾,返回‐1 read = fis.read(); System.out.println( read); // 关闭资源 fis.close(); } } 输出结果: a b c d e ‐1
循环改进读取方式,代码演示:
public class FISRead { public static void main(String[] args) throws IOException{ // 使用文件名称创建流对象,文件内容为abcde FileInputStream fis = new FileInputStream("read.txt"); // 定义变量,保存数据 int b ; // 循环读取 while ((b = fis.read())!=‐1) { System.out.println((char)b); } // 关闭资源 fis.close(); } } 输出结果: a b c d e
小贴士:
- 虽然读取了一个字节,但是会自动提升为int类型。
- 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
- 使用字节数组读取: read(byte[] b) ,每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回 -1 ,代码演示:
public class FISRead { public static void main(String[] args) throws IOException{ // 使用文件名称创建流对象,文件内容为abcde FileInputStream fis = new FileInputStream("read.txt");// 定义变量,作为有效个数 int len ; // 定义字节数组,作为装字节数据的容器 byte[] b = new byte[2]; // 循环读取 while (( len= fis.read(b))!=‐1) { // 每次读取后,把数组变成字符串打印 System.out.println(new String(b)); } // 关闭资源 fis.close(); } } 输出结果: ab cd ed
public class FISRead { public static void main(String[] args) throws IOException{ // 使用文件名称创建流对象,文件内容为abcde FileInputStream fis = new FileInputStream("read.txt"); // 定义变量,作为有效个数 int len ; // 定义字节数组,作为装字节数据的容器 byte[] b = new byte[2]; // 循环读取 while (( len= fis.read(b))!=‐1) { // 每次读取后,把数组的有效字节部分,变成字符串打印 System.out.println(new String(b,0,len));// len 每次读取的有效字节个数 } // 关闭资源 fis.close(); } } 输出结果: ab cd e
小贴士:
使用字节数组读取数据明确两件事情:
- 方法的参数byte[]的作用?
起到缓冲作用,存储每次读取到的多个字节
数组的长度一般定义为1024(1kb)或者1024的整数倍 - 方法的返回值int是什么?
每次读取的有效字节个数
字节流案例
案例实现:
public class Copy { public static void main(String[] args) throws IOException { // 1.创建流对象 // 1.1 指定数据源 FileInputStream fis = new FileInputStream("D:\\test.jpg"); // 1.2 指定目的地 FileOutputStream fos = new FileOutputStream("test_copy.jpg"); // 2.读写数据 // 2.1 定义数组 byte[] b = new byte[1024]; // 2.2 定义长度 int len; // 2.3 循环读取 while ((len = fis.read(b))!=‐1) { // 2.4 写出数据 fos.write(b, 0 , len); } // 3.关闭资源 fos.close(); fis.close(); } }
小贴士:
- 流的关闭原则:先开后关,后开先关。
字符流
字符输出流【Writer】
- void write(int c) 写入单个字符。
- void write(char[] cbuf) 写入字符数组。
- abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分,offff数组的开始索引,len写的字符个数。
- void write(String str) 写入字符串。
- void write(String str, int off, int len) 写入字符串的某一部分,offff字符串的开始索引,len写的字符个数。
- void flush() 刷新该流的缓冲。
- void close() 关闭此流,但要先刷新它。
FileWriter类
构造方法
- FileWriter(File file) : 创建一个新的 FileWriter,给定要写入数据的File对象。
- FileWriter(String fileName) : 创建一个新的 FileWriter,给定要写入数据的文件的名称。
构造举例,代码如下:
public class FileWriterConstructor { public static void main(String[] args) throws IOException { // 使用File对象创建流对象 File file = new File("a.txt"); FileWriter fw = new FileWriter(file); // 使用文件名称创建流对象 FileWriter fw = new FileWriter("b.txt"); } }
写出字符数据
- 写出字符: write(int b) 方法,每次可以写出一个字符数据,代码使用演示:
public class FWWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 FileWriter fw = new FileWriter("fw.txt"); // 写出数据 fw.write(97); // 写出第1个字符 fw.write('b'); // 写出第2个字符 fw.write('c'); // 写出第3个字符 fw.write(30000); // 写出第4个字符,中文编码表中30000对应一个汉字。 /*【注意】关闭资源时,与FileOutputStream不同。 如果不关闭,数据只是保存到缓冲区,并未保存到文件。 */ fw.close(); } } 输出结果: abc田
小贴士:
- 虽然参数为int类型四个字节,但是只会保留一个字符的信息写出。
- 如果未调用close方法,数据只是保存到了缓冲区,并未写出到文件中。
- 写出字符数组 : write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ,每次可以写出字符数组中的数据,用法类似FileOutputStream,代码使用演示:
public class FWWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 FileWriter fw = new FileWriter("fw.txt"); // 字符串转换为字节数组 char[] chars = "张三李四王五".toCharArray(); // 写出字符数组 fw.write(chars); // 张三李四王五 // 写出从索引2开始,2个字节。索引2是'李',两个字节,也就是'李四'。 fw.write(b,2,2); // 李四 // 关闭资源 fos.close(); } }
- 写出字符串: write(String str) 和 write(String str, int off, int len) ,每次可以写出字符串中的数据,更为方便,代码使用演示:
public class FWWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 FileWriter fw = new FileWriter("fw.txt"); // 字符串 String msg = "张三李四王五"; // 写出字符数组 fw.write(msg); //张三李四王五 // 写出从索引2开始,2个字节。索引2是'李',两个字节,也就是'李四'。 fw.write(msg,2,2); // 李四 //关闭资源 fos.close(); } }
- 续写和换行:操作类似于FileOutputStream。
public class FWWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象,可以续写数据 FileWriter fw = new FileWriter("fw.txt",true); // 写出字符串 fw.write("张三"); // 写出换行 fw.write("\r\n"); // 写出字符串 fw.write("李四"); // 关闭资源 fw.close(); } } 输出结果: 张三 李四
关闭和刷新
- flush :刷新缓冲区,流对象可以继续使用。
- close :先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。
代码使用演示:
public class FWWrite { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 FileWriter fw = new FileWriter("fw.txt"); // 写出数据,通过flush fw.write('刷'); // 写出第1个字符 fw.flush(); fw.write('新'); // 继续写出第2个字符,写出成功 fw.flush(); // 写出数据,通过close fw.write('关'); // 写出第1个字符 fw.close(); fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closed fw.close(); } }
小贴士:
字符输入流【Reader】
- public void close() :关闭此流并释放与此流相关联的任何系统资源。
- public int read() : 从输入流读取一个字符。
- public int read(char[] cbuf) : 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中 。
FileReader类
小贴士:
- 字符编码:字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。idea中是UTF-8。
- 字节缓冲区:一个字节数组,用来临时存储字节数据。
构造方法
- FileReader(File file) : 创建一个新的 FileReader ,给定要读取的File对象。
- FileReader(String fileName) : 创建一个新的 FileReader ,给定要读取的文件的名称。
构造举例,代码如下:
public class FileReaderConstructor throws IOException{ public static void main(String[] args) { // 使用File对象创建流对象 File file = new File("a.txt"); FileReader fr = new FileReader(file); // 使用文件名称创建流对象 FileReader fr = new FileReader("b.txt"); } }
读取字符数据
- 读取字符: read ()方法,每次可以读取一个字符的数据,提升为int类型,读取到文件末尾,返回 -1 ,循环读取,代码使用演示:
public class FRRead { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 ,文件内容:张三李四王五 FileReader fr = new FileReader("read.txt"); // 定义变量,保存数据 int b ; // 循环读取 while ((b = fr.read())!=‐1) { System.out.println((char)b); } // 关闭资源 fr.close(); } } 输出结果: 张 三 李 四 王 五
小贴士:
- 使用字符数组读取: read(char[] cbuf) ,每次读取b的长度个字符到数组中,返回读取到的有效字符个数,读取到末尾时,返回 -1 ,代码使用演示:
public class FISRead { public static void main(String[] args) throws IOException { // 使用文件名称创建流对象 ,文件内容:张三李四王五 FileReader fr = new FileReader("read.txt"); // 定义变量,保存有效字符个数 int len ; // 定义字符数组,作为装字符数据的容器 char[] cbuf = new char[2]; // 循环读取 while ((len = fr.read(cbuf))!=‐1) { System.out.println(new String(cbuf,0,len)); } // 关闭资源 fr.close(); } } 输出结果: 张三 李四 王五
总结
关于IO流更多内容(包括缓冲、转换、序列化、重定向等),请看下一篇https://www.cnblogs.com/gbxblog/p/14068170.html