Java 文件操作 和 IO（4）-- Java文件内容操作（2）-- 字符流操作

Java 文件操作 和 IO（4）-- Java文件内容操作（2）-- 字符流操作

观前提醒：

在看这篇博客之前，建议你先看完这两篇博客：

Java 文件操作 和 IO（2）-- Java文件系统操作

Java 文件操作 和 IO（1）-- 文件相关知识背景介绍

---

惯例，在讲之前，我们还是需要再来看看，java当中，操作文件的简单介绍，知道文件操作的区分，脑里有个大概的图，才能更好的理解这部分的知识！

---

1. Java中操作文件的简单介绍

使用java来操作文件，主要是通过java标准库提供的一系列的类，而这些类，又可以分为两种操作方向：

1. 文件系统操作：
   这里主要是关于 文件 或 目录 的创建，文件的删除，文件的重命名，创建目录等…

2. 文件内容操作：
   这里就是对某一个具体的文件的内容进行读和写了，又由于文件有两种种类，所以，我们又区分了字节流操作和字符流操作。
   （1）字节流：读写文件，以字节为单位，是针对二进制文件使用的。
   （2）字符流：读写文件，以字符为单位，是针对文本文件使用的。

用一张图来看的话，是这样的：

这篇博客里面，讲的是文件内容操作中的字符流操作，下一篇博客，Java 文件操作 和 IO（5）是文件IO部分的最后一篇博客，主要讲三道题目，综合的使用一下 文件系统操作 和 文件内容操作学过的东西。

2. Java文件内容操作–字符流

字符流操作，主要是两个类：Reader类 和 Writer类，这两个类，同样是 抽象类，抽象类不能够直接通过自己来实例化对象，需要通过 new子类对象来实例化对象。

2.1字符流：Reader类（输入）

2.1.1 Reader类的介绍

Reader类是一个抽象类，本身不能够实例化对象，需要用它的子类对象，来实例化对象。
Reader类的子类，有很多，我们本篇博客使用的是：FileReader类。
FileReader类 是针对文本文件进行 读 操作的一个类。

使用 FileReader类 实例化对象的注意点：

1. 实例化对象的时候，我们需要传入参数

传入的参数，可以是一个路径，绝对路径，相对路径都可以，也可以是一个File对象（如何创建一个File对象，并把File对象，作为参数，在Java 文件操作 和 IO（2）-- Java文件系统操作已经讲过了）
这一块，我的演示就以相对路径："./test.txt"，作为例子，test.txt 为文本文件：

2. 使用FileInputStream类的时候，我们需要处理一个异常 FileNotFoundException

如果你当前传入的这个路径，计算机没有找到文件，就会抛出这个异常。

这里处理异常的方式，直接在main( )方法 的后面 加 throws FileNotFoundException，或者使用 catch捕捉异常，就可以了，抛出异常时，交给JVM处理就行（这块不懂的，可以看看我写的JAVA 异常）。

2.1.2 读取文件内容的操作（四种 read 方法）

1. 不带参数的 read( )方法，返回值是：int 类型

这个方法的作用是：调用一次，读取一个字符。

关于返回值的解释：返回的是int类型的数值，当返回值为 -1 时，表示文件已经读取完毕。

返回值的范围：（四种 read( ) 方法都是）

演示：

1. 读取文件中的英文字符

现在在我本人的java项目路径当中，存在 test.txt 文件，文件当中，写的是 hello ，现在我使用循环，使用字符读取的方式，将里面的内容读取出来：

演示代码：

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;public class demo7 {public static void main(String[] args) {try(Reader reader = new FileReader("./test.txt")){while (true) {int c = reader.read();if (c == -1) {break;}System.out.println((char) c);
//                注意：这里需要进行强制类型转换}} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

注意一点：输出的代码System.out.println((char) c);，需要进行强制类型转换，才能显示出字符，因为你返回的是int类型的数据，不是 char类型。

2.读取文件中的中文文字

现在在我本人的java项目路径当中的 test.txt 文件，文件当中，写的是 你好 ，现在我使用循环，使用字符读取的方式，将里面的内容读取出来：

演示代码：

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;public class demo7 {public static void main(String[] args) {try(Reader reader = new FileReader("./test.txt")){while (true) {int c = reader.read();if (c == -1) {break;}System.out.println((char) c);
//                注意：这里需要进行强制类型转换}} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

需要注意的一点：

我们在进行代码演示之前，说明了 read( )方法返回值的范围

read( ) 返回的相当于是一个 char ，也就是两个字节表示范围

在 java中，一个汉字的大小是两个字节，也就是 char。
上述的运行结果中，“你好”，两个汉字，分别是一个char，也就是两个字节。

但是，在 Java 文件操作 和 IO（3）-- Java文件内容操作（1）-- 字节流操作中，我们使用 字节流 对这两个汉字进行读取操作的时候，‘你’ 和 ‘好’，各自占据 三个字节。

字符流读取：一个汉字是一个 char，两个字节
字节流读取：一个汉字是 三个字节
那么，问题来了：一个汉字，到底占多少个字节？
答：这两种情况，都是对的，不矛盾，占几个字节，取决于我们的代码怎么写。

解释：
字节流：读到的是文件中原始的数据，一个汉字，在硬盘上保存文件的时候，就是 3 个字节一个汉字，使用的是 utf8编码集。

字符流：读取的时候，就会根据文件的内容编码格式，进行解析，read( )一次，就会读取到 3 个字节（按照utf8解析的），返回的时候，针对 3 个字节进行转码：
拿着刚刚读取到的 3 个特点字节，查了一下 utf8 的码表，发现是 ‘你’ 这个汉字，read() 就又把 ‘你’ 这个汉字，在 Unicode 这个码表中再次查询一次，得到了Unicode的编码值，最终把 Unicode 的编码值返回到 char 变量中（此时，‘你’，就是两个字节的大小）。

也就是说，使用 字符流 进行读取汉字的时候，read()方法会自动进行转码（utf8编码 --> Unicode编码）

拓展来说：
自动转码，是有性能开销的，所以，字节流 比 字符流 快，这是毋庸置疑的。
但是，话又说回来，在当今时代，执行速度快重要，还是代码写的快更重要？
执行速度快 => 运行效率
代码写的快 => 开发效率
在2025年的今天，我们更加注重 开发效率！！！

比如说：我想读取到文件中的第二个汉字，使用字符流来做，只需要 read() 两次，就可以了。

但是，如果使用 字节流来呢？
1.先要想办法判定当前文件的编码
2.手动编写代码实现查码表，进行转码
这样就太麻烦了！！！

所以，牺牲一点运行效率，来提升开发效率，是很值得的！

2. 带 char[ ] 参数的read( )方法，返回值是：int 类型

此方法的作用：一次读取一个字符数组（char[ ]），尽可能的把字符数组给填满，返回值int，表示实际读取到的字符个数。

这里的 read( )方法，需要注意的东西，以及一些解释，和 字节流里面的同样带有这个参数的 read( )方法是一样的，这里就不解释那么多了，直接进行演示代码，看看效果就行了。

如果你是第一次点击进来看这篇博客的，还没有看过 Java 文件操作 和 IO（3）-- Java文件内容操作（1）-- 字节流操作的，建议你点击这篇博客，再看回来这里。

由于第一个read()方法，已经演示了英文字符和中文字符的读取了，后面的read()方法，就只演示 中文字符的读取了。

演示：

和第一个read()方法的演示一样，以 test.txt 文件，读取里面的 “你好”，两个汉字。

思路：创建 char[ ] 数组，循环读取 test.txt 文件里面的字符，读取到的字符，存放到 char[ ]数组里面，定义 n 记录真实读取到的字符个数，接着循环输出读取到的字符。

演示代码：

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;public class demo9 {public static void main(String[] args) {try(Reader reader = new FileReader("./test.txt")) {char[] buf = new char[1024];while(true) {int n = reader.read(buf);if (n == -1) {break;}
//    注意这里的循环的条件，是 i<n,n为读取到的字符的个数for (int i = 0;i < n;i++) {System.out.println(buf[i]);}}} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

注意循环条件为 i < n ，n为真实读取到的字符的个数。

3. 带 三个参数的 read( )方法，返回值是：int

对这三个参数进行解释：

char[ ] cbuf ：就是你定义的空白字符数组，调用 read()方法，后，读取到的字符，存放到这个数组里面。

int off ：off --> offset 表示的是 偏移量（数组下标），本次读取到的字符，从空白字符数组的 off 下标 开始存放，限制了存放的起始位置。

int len ：表示你本次读取，想读取多少个字符往空白字符数组 cbuf 中的哪个起始位置 off 开始存放，限制了你本次可以读取到的字符，len 往往会和返回值的大小（本次读取到了多少个字符）是一样的。

所以这个read()方法的作用就是：想读取多少（len）个字符往空白字符数组 cbuf 中的哪个起始位置 off下标 开始存放。

这个方法的使用场景通常是：你有一个非常大的字符数组，每次读操作，都把数据放到数组的某个部分，就会使用到这个 带有三个参数的 read()方法。

演示：

以 test.txt 文件，读取里面的 “你好”，两个汉字。

思路：创建 char[ ] 数组，循环读取 test.txt 文件里面的字符，读取到的字符，存放到 char[ ]数组里面，同时，规定存放的起始位置为：数组下标为 1 的位置（off = 1），一次读取 2 个字符（len = 2），定义 leng 记录真实读取到的字符个数，接着循环输出读取到的字符。

演示代码：

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;public class demo10 {public static void main(String[] args) {try(Reader reader = new FileReader("./test.txt")) {char[] buf = new char[1024];while(true) {int leng = reader.read(buf,1,2);System.out.println("leng = " + leng);if (leng == -1) {break;}for (int i = 1; i <= leng; i++) {System.out.println(buf[i]);}System.out.println("================");}System.out.println(buf[1]);} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

这里有 3 个需要注意的地方：

1. 一次性读取的字符（len）和 返回的本次已读取到的字符数（以此处的 leng为例，大小是一样的）
2. for循环输出本次读取到的字符，循环里的起始条件，i 应该要等于你存放字符的起始下标（此处为例，i = 1）
3. for循环输出本次读取到的字符，循环里的结束条件，i 应该要 小于等于 本次读取到的字符数 （此处为例，i <= leng）

所以，代码是灵活多变的，需要你自己会调试，让代码来呈现出你想要达到的结果。

2.2 字符流：Writer类（输出）

2.1.1 Writer类的介绍

Writer类是一个抽象类，本身不能够实例化对象，需要用它的子类对象，来实例化对象。
Writer类的子类，有很多，我们本篇博客使用的是：FileWriter类。
FileWriter类是针对文本文件进行 写 操作的一个类。

当然，针对 FileWriter类 的使用，同样需要注意两点：
1. FileWriter类的括号里面需要传入参数

传入的参数，可以是一个路径，绝对路径，相对路径都可以，也可以是一个File对象（如何创建一个File对象，并把File对象，作为参数，在Java 文件操作 和 IO（2）-- Java文件系统操作已经讲过了）

这里我就以 “ output.txt ” 为例子（就算你项目路径下没有这个文件，你使用OutputStream类的时候，也会自动创建，这个后面讲）

2. 需要处理异常

处理异常这里，就不细说了，和 Reader类 开头介绍注意事项的处理异常那块所讲的大差不差。

2.1.2 写文件内容的操作（五种 write 方法）

以下的 write()方法 的演示，就以 output.txt 为目标文件，向里面写入字符数据。

1. 带 int 参数的 write( )方法

这里的 int 指的是 字符数据（也可以认为是插入 字符 的 ASCII码 值）
例如：需要往 output.txt 里面写一个 字符 ‘a’，此时 write( )方法 括号里面，就填写的 是 小写字母 ‘a’ 所代表的 ASCII码，97

演示：

演示代码：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;public class demo8 {public static void main(String[] args) {try(Writer writer = new FileWriter("./output.txt")) {
//   97 是ASCII码值，表示的是 小写字母 ‘a’writer.write(97);} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

2. 带 char[ ] 参数的 write( )方法

往 output.txt 文件里面，写入 ‘a’，‘b’，‘c’ 这三个字符。

演示：

演示代码：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;public class demo11 {public static void main(String[] args) {try(Writer writer = new FileWriter("./output.txt")) {char[] chars = new char[]{'a','b','c'};writer.write(chars);} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

3. 带 String 参数的 write( )方法

这个方法就是往 write( )方法 的括号里面，写一个字符串。

例如：我想往 output.txt 文件中，写入 “Hello World！” 。

演示：

演示代码：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;public class demo12 {public static void main(String[] args) {try(Writer writer = new FileWriter("./output.txt")) {
//            先创建字符串对象，然后再写入
//            String s = new String("Hello World!");
//            writer.write(s);//            直接在 write方法括号里 指定字符串writer.write("Hello World!!!");} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

4. 以 char[ ]为例，带三个参数的 write( )方法

off 和 len ，已经介绍过很多次了，这里就不再介绍了。

演示思路：
先创建一个 char[ ]数组，里面存放 ‘a’，‘b’，‘c’ 这三个字符，从 a 开始，就是 0下标。

现在需要往 output.txt 文件里面，添加 char[ ]数组，起始下标为 1 的元素（字符 ‘ b ’），写入两个字符，也就是往 output.txt 文件，写入 ‘b’，‘c’ 两个字符。

演示：

演示代码：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;public class demo13 {public static void main(String[] args) {try(Writer writer = new FileWriter("output.txt")) {char[] chars = new char[]{'a','b','c'};writer.write(chars,1,2);} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

5. 以 String为例，带三个参数的 write( )方法

这个方法的作用：规定某一个字符串的起始字符，并写入具体个数的字符
off 是起始下标，字符串中的首位字符，也是从 0下标 开始的。
len 是写入的字符个数，从起始字符开始，往后数 len 个字符。

例如：以 “hello”，这个字符串为例，从 1 下标开始，往后写入 3个字符 到 output.txt 文件。
运行的结果，output.txt文件显示的应该是：“ell”

演示：

演示代码：

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;public class demo14 {public static void main(String[] args) {try(Writer writer = new FileWriter("./output.txt")) {
//            先创建字符串对象，然后再写入String s = new String("hello");writer.write(s,1,3);//            直接在 write方法括号里 指定字符串
//            writer.write("hello",1,3);} catch (IOException e) {throw new RuntimeException(e);}}
}

运行结果：

3. Java文件内容操作的总结

3.1 文件内容操作使用到的类

开始写文件内容操作，我们讲到过，InputStream，OutputStream，Reader，Writer 这四个类，都是抽象类，
抽象类，不能够直接创建对象，需要使用他们的子类，才能够 创建对象，故而我们需要学习 8 个类，分别是：

1. InputStream 和 FileInputStream（用于字节流的 输入 操作，也就是字节类型文件的 读取 操作）
2. OutputStream 和 FileOutputStream（用于字节流的 输出 操作，也就是字节类型文件的 写 操作）
3. Reader 和 FileReader（用于字符流的 输入 操作，也就是字符类型文件的 读取 操作）
4. Writer 和 FileWriter（用于字符流的 输出 操作，也就是字符类型文件的 写 操作）

3.2 文件内容操作需要掌握的两点

3.2.1 关于流对象的使用流程

先打开，再读写，最后进行关闭

打开和关闭，就是 使用 try with resource 语法，其中注意的点，在 Java 文件操作 和 IO（3）-- Java文件内容操作（1）-- 字节流操作，已经介绍过了

读写，就是我们讲的 字节流 和 字符流 的操作。

3.2.2 读写操作，应该使用哪个流对象

第一步：先区分我们要读写的文件，是文件文件，还是二进制文件
第二步：再去根据我们是要 读文件，还是写文件，来调用具体的类，即可
最后：根据实际需要，编写代码即可

4. 总结

本篇博客介绍了文件内容操作中的 字符流 操作。
如果有一部分代码，没看懂的，例如 try with resource 语法，建议看完Java 文件操作 和 IO（3）-- Java文件内容操作（1）-- 字节流操作中介绍的，再来看本篇博客。

之后，还有一篇博客，是关于文件操作的综合练习， Java 文件操作 和 IO（5）-- 综合案例练习，也可以再看看，加深你对Java 文件操作 和 IO 这方面的知识的理解。

最后，如果这篇博客能帮到你的，请你点点赞，有写错了，写的不好的，欢迎评论指出，谢谢！