Java字符流详解：FileReader与FileWriter的实战应用-优快云博客

本文链接：https://blog.youkuaiyun.com/crazyhsl/article/details/111241909

字符流

当使用字节流读取文件文件的时候，可能会引发一点小问题。如果你遇到了中文字符时，可能不会显示完整的字符。那就是因为一个中文字符可能占用多个字节存储。所以Java提供了一些字符流类，以字符为单位读写数据，专门用于处理文本文档文件。

字符输入流【Reader】

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存当中，它定义了字符输入流的基本共性的api方法：

public void close()：关闭此输入流并且释放与此流相关的其他系统资源。
public int read()：从输入流中读取一个字符。
public int read(char[] chuf)：从输入流中一次读取多个字符，并将它们存储到字符数组chuf当中。

FileReader类

java.io.FileReader类主要是用于读取字符文件的便捷类。构造方法使用时默认的编码字符集和默认的字节缓冲区。

备注：

  1. 字符编码：字节与字符的对应规则。Windows系统中的中文编码默认是GBK编码表，idea中采用UTF-8
  2. 字节缓冲区：一个字节数组，用来临时存储字节数据。

构造方法

FileReader(File file)：创建一个新的FileReader对象，指定需要读取的file对象。
FileReader(String filename)：创建一个新的FileReader对象，指定需要读取的文件名称。

当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream。

使用字符数组读取数据：read(char[] chuf)，每次读取chuf的长度个字符到数组当中，返回读取到有效字符的个数。

当它读取到末尾时，返回-1。

// 1.创建对象，构造方法中绑定需要读取的文件数据源
FileReader fr = new FileReader("day28_IO\\c.txt");
char[] chuf = new char[1024];
int len = 0;// 记录的是每次读取的有效的字符个数
//2. 使用该对象中的方法read()来读取文件数据
while ((len = fr.read(chuf)) != -1) {
    // 字符数组转换成字符串  
    System.out.println(new String(chuf,0,len));
}
// 3.释放资源，关闭此输入流。
fr.close();

字符输入流及子类代码演示：

import java.io.FileReader;
import java.io.IOException;


/*
  使用字符输入流读取文件数据
  java.io.Reader：是所有的字符输入流的顶级父类。
  共性的成员方法：
    public  void  close（）：关闭此输入流并且释放与此流相关的其他系统资源。

    public int   read():从输入流中读取一个字符。

    public  int read(char[] chuf):从输入流中一次读取多个字符，并将他们存储到字符数组chuf当中。
   java.io.FileReader extends InputStreamReader extends Reader
   文件字符输入流
   作用：就是把硬盘当中的数据以字符的形式读取到内存中。
   构造方法：
   完全模仿FileInputStream
      参数：读取文件的数据源
          string filename；文件路径
          File file：一个文件
     FileReader构造方法的作用：
        1.创建一个FileReader对象
        2.会把创建的FileReader对象指向需要读取的文件
     字符输入流的使用步骤：完全模仿FileInputStream
        1.创建对象，构造方法中绑定需要读取的文件数据源
        2.使用该对象中的方法read()来读取文件数据
        3.释放资源，关闭此输入流


 */
public class DemoFileReader {
    public static void main(String[] args) throws IOException {
        demo4();
    }
    public  static  void demo4() throws IOException{
        //1.创建对象，构造方法中绑定需要读取的文件数据源
        FileReader fileReader = new FileReader("day28--IO\\C.TXT");
        // 2.使用该对象中的方法read()来读取文件数据
        //int read()读取单个字符并返回
        // int len=fileReader.read();
        // System.out.println((char)len);
//        int l=0;//一次读取一个字符
//        while ((l=fileReader.read())!=-1){
//            System.out.print((char)l);
//        }
        //int read(char[] chuf):一次读取多个字符，将字符存储在字符数组chuf中
        char[] chars=new char[4];//
        int l=0;//记录的是每次读取的有效的字符个数
        while ((l=fileReader.read(chars))!=-1){
            /*
            字符数组转换成字符串
            String static valueOf()
            String (char[] value)
            String (char[] value,int offset,int count)
             */
            System.out.println(String.valueOf(chars, 0, l));
        }
        //3.释放资源，关闭此输入流
        fileReader.close();
    }
  
}

字符输出流【Writer】

java.io.Writer抽象类是表示用于输出字符流的所有类的超类。将指定的字符信息写入到目的地中。它定义了字符输出流的基本共性的api方法：

void write(int c)：写入单个字符。
void write(char[] chuf)：写入字符数组。
abstract void write(char[] chuf,int off,int len)：写入char数组的一部分，从char数组的起始索引值off开始，len个写入字符个数。
void write(String str)：写入字符串。
void write(String str,int off,in len)：写入字符串的一部分，从字符串的起始索引off开始，写入len个字符个数。
void flush()：刷新该流的缓冲。
void close()：关闭此流，但是需要先刷新它。

FileWriter类

java.io.FileWriter类是用于写入字符到文件中。构造方法使用系统默认的字符编码和默认的字节缓冲区。

构造方法

FileWriter(File file)：创建一个新的FileWriter，指定写入的file对象。
FileWriter(String filename)：创建一个新的FileWriter，指定需要写入的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

public static void main(String[] args) throws IOException {
        // 1.创建一个FileWriter对象，构造方法中绑定需要写入数据的目的地。
        FileWriter fw = new FileWriter("day28_IO\\e.txt");
        // 2.使用fileWriter对象中的方法write，把数据写入到内存缓冲区中(字符转换为字节的过程)
        // void write(int c) 写入单个字符
        fw.write(122);// K  z
        // 3.使用FileWriter对象的中的方法flush，把内存缓冲区中的数据刷新到文件中。
        //fw.flush();
        // 4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
        fw.close();
 }

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写入字符到文件中。但是关闭流对象，是无法继续写入数据到文件中。如果既想写入数据到文件中，又想继续使用流对象，那么就需要flush方法。

flush：刷新缓冲区，流对象可以继续使用
close：先刷新缓冲区，然后会通知系统释放资源，关闭流对象，流对象不可以再使用。

public static void main(String[] args) throws IOException {
        // 1.创建对象
        FileWriter fw = new FileWriter("day28_IO\\e.txt");
        // 2.调用write方法
        fw.write(97);// a
        // 3. 刷新
        fw.flush();
        // 刷新之后流可以继续使用
        fw.write(98);
        // 4. 关闭流对象
        fw.close(); 
       // close方法之后，流已经关闭了，已经从内存当中消失了，流不能再使用了，如果使用抛出Stream closed 
        fw.write(99);
    }

写入字符数组:write(char[] chuf)和write(char[] chuf,int off,int len),每次可以写入一个字符数组的数据，用法类似于FileOutputStream

//1. new
        FileWriter fw = new FileWriter("day28_IO\\f.txt");
        //2. write
        //2.1 char[]
        char[] chars = new char[]{'a','b','c','d','e','f'};
        fw.write(chars);// abcdef
        //abstract void write(char[] chuf,int off,in len)：写入字符数组的一部分，从off起始索引开始，写入len个字符个数
        fw.write(chars, 3, 3);// def
        //void write(String str)：写入一个字符串
        fw.write("你好,Java");
        //void write(String str,int off,int len)：写入字符串的一部分，从off起始索引开始，写入len个字符个数
        fw.write("你好,Java",3,4);// Java
        //3. flush
        //fw.flush();
        //4. 关闭
        fw.close();

续写和换行：操作类似于FileOutputStream

public static void main(String[] args) throws IOException {
        // 1. new
        FileWriter fw = new FileWriter("day28_IO\\g.txt", true);
        //2. write
        char[] chars = new char[50];
        //fw.write();
        for (int i = 0; i < 50; i++) {
            chars[i] = (char) (20000+i);
            fw.write(chars[i] + "\r\n");//换行性质
        }
        //3. 刷新
        fw.flush();
        //4. 关闭
        fw.close();
    }