Java的输入和输出处理（二）字符篇

回顾

昨天我们学习了对文件进行字节的输入（InputStream）和字节的输出（OutputStream）。今天进行扩展，是在昨天的基础上处理的，相比于字符上的处理，我们工作更习惯于使用字节。

使用字符流读写文本文件

字符输入Reader类

常用方法
可以使用Markdown表格来列举Java中Reader类的常用方法。下面是一个示例：

方法	描述
`int read()`	读取单个字符并返回其Unicode值，如果到达流的末尾，则返回-1。
`int read(char[] c)`	将字符读入数组c，并返回读取的字符数。如果到达流的末尾，则返回-1。
`int read(char[] c, int off, int len)`	将字符读入数组cbuf的指定部分，并返回读取的字符数。如果到达流的末尾，则返回-1。
`long skip(long n)`	跳过n个字符，并返回实际跳过的字符数。
`boolean ready()`	判断是否可以从流中读取字符，返回true表示可以读取，false表示不可读取。
`void close()`	关闭流并释放与之关联的所有系统资源。

请注意：Reader基类、Writer基类与InputStream、OutputStream基类一样都是抽象类，不可以被实例化，都是由其子类实例化

Reader类的子类InputStreamReader

常用的构造方法：
InputStreamReader(InputStream in)
InputStreamReader(InputStream in,String charsetName)

charseName是字符编码的意思

InputStreamReader的子类`FileReader类`

FileReader类只可以按照本地平台的字符编码来读取数据，用户不可以指定其他的字符编码类型

获得本地平台的字符编码类型
System.out.println(System.getProperty(file.encoding))
常用方法：
可以使用Markdown表格来列举Java中FileReader类的常用方法。下面是一个示例：

方法	描述
`int read()`	读取单个字符并返回其Unicode值，如果到达流的末尾，则返回-1。
`int read(char[] cbuf)`	将字符读入数组cbuf，并返回读取的字符数。如果到达流的末尾，则返回-1。
`int read(char[] cbuf, int off, int len)`	将字符读入数组cbuf的指定部分，并返回读取的字符数。如果到达流的末尾，则返回-1。
`long skip(long n)`	跳过n个字符，并返回实际跳过的字符数。
`boolean ready()`	`判断是否可以从流中读取字符，返回true表示可以读取，false表示不可读取。`
`void close()`	关闭流并释放与之关联的所有系统资源。

构造方法

FileReader(File file)
FileReader(String name)

BufferedReader类

用来提高字符流读取文本文件的效率
常用的构造方法
BufferedReader(Reader in）
在这里插入图片描述
举例：

package 面向对象.文件的输入与输出;

import java.io.*;

public class 字符流输入 {
    public static void main(String[] args) {
        try {
            // 调用测试方法
//            testreader1();
            testreader2();
//            testreaderBuff();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void testreader1() {
        //FileReader子类 继承 InputStreamReader父类 继承 Reader基类
        // 创建字符输入流对象
        Reader reader = null;
        try {
            // 创建FileReader对象，指定文件路径
            reader = new FileReader("C:\\Java\\a.txt");
            int data;
            while ((data = reader.read()) != -1) {
                // 将读取到的字符转换为char并打印输出
                System.out.println((char) data);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭流
                reader.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void testreader2() {
        // 创建字符输入流对象
        Reader reader = null;
        FileInputStream fis = null;
        try {
            // 创建FileInputStream对象，指定文件路径
            fis = new FileInputStream("C:\\Java\\a.txt");
            // 创建InputStreamReader对象，将字节流转换为字符流，并指定字符编码为UTF-8
            reader = new InputStreamReader(fis, "UTF-8");
            char ch[] = new char[1024];
            StringBuffer sb = new StringBuffer();
            int data;
            while ((data = reader.read(ch)) != -1) {
                // 将读取到的字符数组转换为字符串，并追加到StringBuffer对象中
                sb.append(ch, 0, data);
            }
            // 将StringBuffer对象转换为字符串并打印输出
            System.out.println(sb.toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭流
                reader.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void testreaderBuff() {
        Reader reader = null;
        BufferedReader br = null;
        try {
            // 创建字符输入流对象
            reader = new FileReader("C:\\Java\\a.txt");
            // 创建BufferedReader对象，将字符输入流包装在其中，实现缓冲功能
            br = new BufferedReader(reader);
            String str = null;
            while ((str = br.readLine()) != null) {
                // 逐行读取文本内容并打印输出
                System.out.println(str);
            }
//            char ch[] = new char[1024];
//            StringBuffer sb = new StringBuffer();
//            int data;
//            while ((data = br.read(ch)) != -1) {
//                sb.append(ch);
//            }
//            System.out.println(sb.toString());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭流
                br.close();
                reader.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

这三个方法实现了不同的字符读取方式：

testreader1() 方法使用 FileReader 类直接读取文件的字符流。它每次读取一个字符并将其转换为 char，然后打印输出。这种方式适用于读取较小的文本文件。

testreader2() 方法使用 InputStreamReader 类将 FileInputStream 的字节流转换为字符流。它使用字符数组作为缓冲区，每次读取一定数量的字符数据，并将其追加到 StringBuffer 对象中。最后，将 StringBuffer 对象转换为字符串并打印输出。这种方式适用于读取较大的文本文件。

testreaderBuff() 方法使用 BufferedReader 类对字符输入流进行缓冲。它包装了 FileReader 对象，并通过 readLine() 方法逐行读取文本内容并打印输出。使用缓冲区可以提高读取效率，尤其适用于大型文本文件。

字符输出流Writer类

常用方法：

方法	描述
`write(int c)`	将指定的字符写入输出流
`write(char[] cbuf)`	将字符数组的内容写入输出流
`write(char[] cbuf, int off, int len)`	将字符数组的指定部分写入输出流
`write(String str)`	将字符串写入输出流
`write(String str, int off, int len)`	将字符串的指定部分写入输出流
`append(char c)`	将指定字符追加到输出流
`append(CharSequence csq)`	将指定字符序列追加到输出流
`append(CharSequence csq, int start, int end)`	将指定字符序列的指定部分追加到输出流
`flush()`	刷新输出流，将缓冲区中的内容写入目标设备
`close()`	关闭输出流，释放与之关联的资源