九、字节流与字符流
9.1 IO的分类
<段落>根据数据的流向分为:输入流和输出流。数据的类型分为:字节流和字符流。
- 输入流 :把数据从其他设备上读取到内存中的流。
- 输出流 :把数据从内存 中写出到其他设备上的流。
- 字节流 :以字节为单位,读写数据的流。
- 字符流 :以字符为单位,读写数据的流。
*父类表:
输入流 输出流 字节流 字节输入流 InputStream 字节输出流 OutputStream 字符流 字符输入流 Reader 字符输出流Writer 9.2字节流输出流
9.2.1 概述:
一切文件数据都是以二进制数字的形式保存,我们要时刻明确,无论使用什么样的流对象,底层传输始终为二进制数据。9.2.2 字节输出流的构造方法:
OutputStream有很多子类,我们从最简单的一个子类开始。
java.io.FileOutputStream类是文件输出流,用于将数据写出到文件。
构造方法
public FileOutputStream(File file):创建文件输出流以写入由指定的 File对象表示的文件。notes: 在进行构造的时候,如果父目录不存在,则会报错,在创建时 父目录存在,但是文件不存在,则会帮你创建。
public FileOutputStream(String name): 创建文件输出流以指定的名称写入文件
notes:
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文件,会清空这个文件的数据。
public static void main(String[] args) throws IOException {
// 创建 File 对象
File file = new File("a.txt");
// 创建文件输出流对象
FileOutputStream fos = new FileOutputStream(file);
// 使用文件 名称创建 输出流对象
FileOutputStream fos1 = new FileOutputStream("a.txt");
fos.close();
fos1.close();
}
9.2.3字节输出流的基本共性方法:
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)
:将指定的字节输出流。
tipps:
close方法,当完成流的操作时,必须调用此方法,释放系统资源。
public static void main(String[] args) throws IOException{
// 在 写的时候 是 将原来的删除 然后再去 写
FileOutputStream fos = new FileOutputStream("fos.txt");
// 写 数据
fos.write(97);
fos.write(98);
//根据 字节数组 写数据
byte[] b = {'1','2','3','4'};
fos.write(b);
// 将指定 段 数据写入
// write(byte[] b, int off, int len) ,每次写出从off索引开始,len个字节
fos.write(b,0,2);
// 关闭
fos.close();
}
-->输出结果:
当没有fos.txt文件时,写入ab123412
有则将其覆盖
tips:
1.虽然 参数 为 int 类型 四个字节 但是 只会保留一个字节的信息写出2.流操作完毕后,必须释放系统资源,调用close方法
数据追加续写: (只需要在 原来的 构造方法 后再加 一个参数 ,true表示 续写,false 表示清空数据)
每次都会 清空目标文件中的数据,如何保留目标文件中数据,还能继续添加数据
构造方法:
写出换行:
public FileOutputStream(File file, boolean append)
: 创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name, boolean append)
\r 回车符 回到一行的开头 \n 换行符另起一行
系统中
Windows 系统里 换行符合为 \r\nUnix系统里 没行结尾只有 换行 即 \n;Mac系统里,每行结尾是 回车,即\r 。从 Mac OS X开始与Linux 统一。
public static void main(String[] args) throws IOException{
// 在 写的时候 是 将原来的删除 然后再去 写
FileOutputStream fos = new FileOutputStream("fos.txt");
// 写 数据
fos.write(97);
fos.write(98);
fos.write("\r\n".getBytes());
//根据 字节数组 写数据
byte[] b = {'1','2','3','4'};
fos.write(b);
// 将指定 段 数据写入
fos.write(b,0,2);
// 关闭
fos.close();
}
结果是:
ab
123412
9.3字节输入流 InputStream
java.io.InputStream
抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close()
:关闭此输入流并释放与此流相关联的任何系统资源。
public abstract int read()
: 从输入流读取数据的下一个字节。
public int read(byte[] b)
: 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
tips:
9.3.1 构造方法
java.io.FileInputStream
类是文件输入流,从文件中读取字节。构造方法
FileInputStream(File file)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
FileInputStream(String name)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出
FileNotFoundException
public static void main(String[] args) throws FileNotFoundException {
File file = new File("a.txt");
// 通过构造方法 创建 输入流对象
FileInputStream fis = new FileInputStream(file);
FileInputStream fis1 = new FileInputStream("a.txt");
}
9.3.2 方法
1.读取字节:read方法,每次可以读取一个字节的数据,提升为int类型,当读取到文件末尾的时候 则会返回 -1 。
可以根据 -1 来判断是否到达文件末尾:
public static void main(String[] args) throws IOException {
File file = new File("fos.txt");
// 通过构造方法 创建 输入流对象
FileInputStream fis = new FileInputStream(file);
FileInputStream fis1 = new FileInputStream("fos.txt");
// 提升成 int 类型
int read = fis.read();
System.out.println("read = " + read); // 如果不转换成 char 类型 则是97 转成char类型则是 a
int read1 = fis.read();
System.out.println("read = " + read1);
int read2 = fis.read();
System.out.println("read = " + read2);
int read3 = fis.read();
System.out.println("read = " + read3);
// 读取到文件末尾就返回 -1
fis.close();
fis1.close();
}
2.对循环进行改进 使用while 循环
public static void main(String[] args) throws IOException {
// 创建文件对象
File file = new File("fos.txt");
// 创建 输入流对象
FileInputStream fis = new FileInputStream(file);
// 通过while 循环 当 b != -1 时 退出
int b;
while ((b = fis.read()) != -1) {
System.out.println("b = " + (char) b);
}
// 关闭流对象
fis.close();
}
tips:1.虽然读取了一个字节,但是会自动提升 为 int 类型2. 流操作完毕后,必须释放系统资源, 调用close方法3.使用字节数组读取 : read(byte[] b), 每次读取b个长度的字节到数组中,返回读取到的有效字节个数 读取到末尾时 返回 -1
public static void main(String[] args) throws IOException{
// 使用文件名称创建流对象.
FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
// 定义变量,作为有效个数
int len ;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=-1) {
// 每次读取后,把数组变成字符串打印
System.out.println(new String(b));
}
// 关闭资源
fis.close();
}
tips:使用数组进行读取,每次读取多个字节,减少系统见4的IO操作的次数,从而 提高了读写的效率,建议开发中使用9.3.3视频的复制
从已有的文件中读取字节,将该字节写出到另一个文件中
public static void main(String[] args) throws IOException {
File file = new File("D:\\111\\shipin.flv");
// 创建 输入流 将文件读入 到内存中
FileInputStream fis = new FileInputStream(file);
// 创建输出流 将数据从内存写入到 文件中
FileOutputStream fos = new FileOutputStream("D:\\2222\\flower.flv");
int len;
byte[] b = new byte[1024];
// 循环读取
while ((len = fis.read(b)) != -1) {
// 写数据
fos.write(b,0,len);
}
fos.close();
fis.close();
}
notes:
流关闭原则: 先开后关,后开先关9.3.4字节缓冲流包装
构造方法:public BufferInputStream(InputStream in): 创建一个新的缓冲输入流
public BufferOutputStream(OutputStream out):创建一个新缓冲输出流
public static void main(String[] args) throws FileNotFoundException {
// 创建 字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
// 创建 字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));
}
实现一个复制视频的操作,联系 BufferInputStream 和 BufferOutputStream
public static void main(String[] args) throws IOException {
// 复制一份视频 用BuffOutputStream
// 创建一个 输入流对象
long start = System.currentTimeMillis();
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/福利赠送.flv"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("s.flv"));
int len;
byte[] b = new byte[1024*8];
while ((len = bis.read(b)) != -1){
bos.write(b);
bos.flush();
}
bos.close();
long end = System.currentTimeMillis();
System.out.println(end-start);
}
9.4 字符流
当使用字节流读取文本文件时,可能会遇到一个小问题。 就是遇到中文字符的时候,可能不会显示完整的字符,那是因为一个中午字符 可能 占用多个字节。所有java提供了一些字符流,以字符为单位读写数据,专门用于处理文本文件。9.4.1 字符输入流【Reader】
java.io.Reader 抽象类是表搜狐用于读取字符流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close()
:关闭此流并释放与此流相关联的任何系统资源。
public int read()
9.4.2 FileReader 类
java.io.FileReader 类是读取字符文件的类,构造时使用系统默认的字符编码和默认字节缓冲区。
tips:
1.字符编码:字节与字符的对应规则。Windows 系统的中午编码默认是GBK 编码表
2.字节缓冲区:一个字节数组,用来临时存储字节数据。构造方法:
FileReader(File file)
: 创建一个新的 FileReader ,给定要读取的File对象。
FileReader(String fileName)
: 创建一个新的 FileReader ,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径,类似于FileInputStream
public static void main(String[] args) throws FileNotFoundException {
File file = new File("a.txt");
// 创建字符输入流对象
FileReader fr = new FileReader(file);
// 使用文件名创建流对象
FileReader fr1 = new FileReader("a.txt");
}
基本方法:1.read方法,每次可以读取一个字符的数据,提升为int类型,读取到文件末尾,返回 -1 ,循环读取
问:为什么 返回值是 int 而不是 byte
答:因为字节输入流可以操作任意类型的文件,比如图片音频等,这些文件底层都是二进制形式存储的,如果每次读取都返回byte,有可能在读到中间的时候遇到111111111 那么这111111111是byte类型的-1我们程序要是遇到 -1 就会停止不读了,后面的数据就读取不到了 所以选择 int接受,如果111111111会在前面补上24个0凑足4个字节,那么byte类型的-1 就变成int类型的255了 这样就可以保证整个数据读完了,而结束标记的-1就是int类型。
public static void main(String[] args) throws IOException {
// a.txt 文件中 有 abc
File file = new File("a.txt");
// 创建字符输入流对象
FileReader fr = new FileReader(file);
// 定义遍历保存数据
int b;
while ((b = fr.read()) != -1) {
System.out.println("b = " + (char)b);
}
fr.close();
}
结果输出:
a
b
c
/** tips:
1.虽然读取了一个字符,但是也会自动提升为int 类型 记得关闭流
*/
2.使用字符数组读取: read(char[] cbuf),每次读取b个长度字符到数组中,返回读取到的有效字符个数,读取到末尾时,返回 -1
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("read.txt");
// 定义遍历 保存有效字符个数
int len;
// 定义字符数组 作为装字符数据的容器
char[] buff = new char[2];
// 进行循环读取
while ((len=fr.read(buff)) != -1){
System.out.println("buff = " + new String(buff));
}
fr.close();
}
结果:
buff = 我是
buff = 爱J
buff = av
buff = a语
buff = 言语
这样会出现 缓冲区 内容 粘包一样的问题
优化;
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("read.txt");
// 定义遍历 保存有效字符个数
int len;
// 定义字符数组 作为装字符数据的容器
char[] buff = new char[2];
// 进行循环读取
while ((len=fr.read(buff)) != -1){
System.out.println("buff = " + new String(buff,0,len));
}
fr.close();
}
结果:
buff = 我是
buff = 爱J
buff = av
buff = a语
buff = 言
9.4.3 字符输出流【Writer】
java.io.Writer 抽象类 是表示用于写出字符流的所有类的超类,将指定的字符信息写到 目的地。它定义了字节输出流的基本共性功能方法。
public abstract void close()
:关闭此输出流并释放与此流相关联的任何系统资源。public abstract void flush()
:刷新此输出流并强制任何缓冲的输出字符被写出。public void write(int b)
:写出一个字符。
1. FielWriter类
java.io.FileWriter 类是写出字符到文件的类 ,构造时 使用系统默认的字符编码和默认字节缓冲区。构造方法:
- FileWriter(File file): 创建一个新的 FileWriter,给定要读取的File对象。
- FileWriter(String fileName): 创建一个新的 FileWriter,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径,类似于FileOutputStream
public static void main(String[] args) throws IOException {
File file = new File("a.txt");
// 通过文件对象创建 字符输出流对象
FileWriter fw = new FileWriter(file);
// 通过文件名字创建一个 字符输出流对象
FileWriter fw2 = new FileWriter("b.txt");
}
基本写出数据方法:write()
write(char[] buff)
write(char[] buff, int off, int len) 与 FileOutputStream
写出字符串
write(String str)和 write(String str , int of ,int len)
flush :刷新缓冲区 ,流对象可以继续使用
close:关闭流 ,释放系统资源,关闭前会刷新缓冲区
public static void main(String[] args) throws IOException {
File file = new File("a.txt");
// 通过文件对象创建 字符输出流对象
FileWriter fw = new FileWriter(file);
fw.write(97);
fw.write('b');
fw.write('c');
fw.write(50000); // 中午编码表中50000对应的一个汉字
fw.close();
}
结果:
abc鱔
notes:
1.虽然参数int 类型是四个字节,但是只会保留一个字符 的信息写出。
2.没有调用close方法,数据只是保存到了缓冲区,并未写出到文件中
3.即便是调用了 flush 方法 写出了数据,操作的最后还是要 关闭流
续写和换行 与FileOutputStream 类似
9.4.4 字符缓冲 输入 输出流
public static void main(String[] args) throws IOException {
// 创建字符 缓冲 输入 输出流
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
// 首先 按照字节进行读取
int len ;
char[] b = new char[1024];
while ((len = br.read(b)) != -1){
bw.write(b,0,len);
bw.flush();
}
bw.close();
br.close();
}
notes:字符流,只能操作文本文件,不能操作图片,视频等非文本文件。
9.4 IO异常的处理
9.4.1 JDK 7 之前处理的方式
我们一直把异常抛出,而实际开发中并不能这样处理,建议使用try...catch...finally 代码块,处理异常部分
public static void main(String[] args) {
// 声明变量
FileWriter fw = null;
try {
//创建流对象
fw = new FileWriter("fw.txt");
// 写出数据
fw.write("我爱JAVA"); //我爱JAVA
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fw != null) {
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
9.4.2 JDK 7 的处理方式
还可以使用JDK7优化后的try-with-resource 语句,该语句确保了每个资源在语句结束时关闭。所谓的资源(resource)是指在程序完成后,必须关闭的对象。
格式:
try (创建流对象语句,如果多个,使用';'隔开) {
// 读写数据
} catch (IOException e) {
e.printStackTrace();
}
演示:
public static void main(String[] args) {
// 创建流对象
try ( FileWriter fw = new FileWriter("fw.txt"); ) {
// 写出数据
fw.write("我爱java"); //我爱java
} catch (IOException e) {
e.printStackTrace();
}
}
9.4.3 JDK9 的改动
JDK9中try-with-resource 的改进,对于引入对象的方式,支持的更加简洁。被引入的对象,同样可以自动关闭,无需手动close,我们来了解一下格式。
改进前的格式:
// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式:创建新的变量保存
try (Resource r1 = resource1;
Resource r2 = resource2) {
// 使用对象
}
改进后的格式:
// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式:直接引入
try (resource1; resource2) {
// 使用对象
}
演示;'
public static void main(String[] args) throws IOException {
// 创建流对象
final FileReader fr = new FileReader("in.txt");
FileWriter fw = new FileWriter("out.txt");
// 引入到try中
try (fr; fw) {
// 定义变量
int b;
// 读取数据
while ((b = fr.read())!=-1) {
// 写出数据
fw.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
}