Java字节流与字符流
九、字节流与字符流
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：
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
<wiz_code_mirror>
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方法，当完成流的操作时，必须调用此方法，释放系统资源。
<wiz_code_mirror>
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 统一。
<wiz_code_mirror>
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
<wiz_code_mirror>
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 来判断是否到达文件末尾：
<wiz_code_mirror>
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 循环
<wiz_code_mirror>
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
<wiz_code_mirror>
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视频的复制
从已有的文件中读取字节，将该字节写出到另一个文件中
<wiz_code_mirror>
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）：创建一个新缓冲输出流
<wiz_code_mirror>
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
<wiz_code_mirror>
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
<wiz_code_mirror>
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类型。
<wiz_code_mirror>
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
<wiz_code_mirror>
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 = 言语
这样会出现 缓冲区 内容 粘包一样的问题
优化;
<wiz_code_mirror>
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
<wiz_code_mirror>
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：关闭流 ，释放系统资源，关闭前会刷新缓冲区
<wiz_code_mirror>
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 字符缓冲 输入 输出流
<wiz_code_mirror>
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 代码块，处理异常部分
<wiz_code_mirror>
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）是指在程序完成后，必须关闭的对象。
<wiz_code_mirror>
格式：
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，我们来了解一下格式。
<wiz_code_mirror>
改进前的格式：
// 被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();
}
}
Powers a lot like real estate.Its all about location, location, location.The closer you are to the source,the higher your property value.
