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

文章目录

Java 文件操作和 IO（4）-- Java文件内容操作（2）-- 字符流操作
观前提醒：
1. Java中操作文件的简单介绍
2. Java文件内容操作--字符流
- 2.1字符流：Reader类（输入）
- - 2.1.1 Reader类的介绍
  - 2.1.2 读取文件内容的操作（四种 read 方法）
  - - 1. 不带参数的 read( )方法，返回值是：int 类型
    - - 演示：
      - 1. 读取文件中的英文字符
        2.读取文件中的中文文字
      - 需要注意的一点：
    - 2. 带 char[ ] 参数的read( )方法，返回值是：int 类型
    - - 演示：
    - 3. 带三个参数的 read( )方法，返回值是：int
    - - 演示：
- 2.2 字符流：Writer类（输出）
- - 2.1.1 Writer类的介绍
  - 2.1.2 写文件内容的操作（五种 write 方法）
  - - 1. 带 int 参数的 write( )方法
    - - 演示：
    - 2. 带 char[ ] 参数的 write( )方法
    - - 演示：
    - 3. 带 String 参数的 write( )方法
    - - 演示：
    - 4. 以 char[ ]为例，带三个参数的 write( )方法
    - - 演示：
    - 5. 以 String为例，带三个参数的 write( )方法
    - - 演示：
3. Java文件内容操作的总结
- 3.1 文件内容操作使用到的类
- 3.2 文件内容操作需要掌握的两点
- - 3.2.1 关于流对象的使用流程
  - 3.2.2 读写操作，应该使用哪个流对象
4. 总结

观前提醒：

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

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

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

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

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

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

文件系统操作：
这里主要是关于文件或目录的创建，文件的删除，文件的重命名，创建目录等…
文件内容操作：
这里就是对某一个具体的文件的内容进行读和写了，又由于文件有两种种类，所以，我们又区分了字节流操作和字符流操作。
（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 个需要注意的地方：

一次性读取的字符（len）和返回的本次已读取到的字符数（以此处的 leng为例，大小是一样的）
for循环输出本次读取到的字符，循环里的起始条件，i 应该要等于你存放字符的起始下标（此处为例，i = 1）
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);
        }
    }
}