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()	关闭输出流，释放与之关联的资源

子类OutputStreamWriter常用的构造方法
OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out,String charsetName)

OutputStreamWriter的子类FileWriter类

构造方法
FileWriter (File file)
FileWriter (String name)

该类只能按照本地平台的字符编码来写数据，用户不能指定其他的字符编码类型

BufferedWriter类

可以使用FileWriter类与BufferedWriter类
提高字符流写文本文件的效率。

• BufferedWriter类是Writer类的子类
• BufferedWriter类带有缓冲区

构造方法
BufferedWriter(Writer out)
用BuffererWriter写文本文件过程

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

import java.io.*;

public class 字符流输出 {
    public static void main(String[] args) {
        try {
            // 调用testWrite方法进行文件写入操作
            // testWrite();
            
            // 调用testWriteAndReader方法进行文件写入和读取操作
            testWriteAndReader();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    public static void testWrite() throws IOException {
        // 创建字符输出流对象
        // FileWriter继承自OutputStreamWriter，用于写入字符流到文件
        Writer writer = null;
        String str = "好好学习Java";
        // 创建文件写入的目标文件路径
        writer = new FileWriter("C:\\Java\\a.txt");

        // 将字符串写入文件
        writer.write(str);
        System.out.println("写入成功");
        // 关闭流，释放资源
        writer.close();
    }

    public static void testWriteAndReader() throws IOException {
        // 创建字符输出流和字符输入流对象
        FileWriter fw = null;
        BufferedWriter bw = null;

        FileReader fr = null;
        BufferedReader br = null;

        // 创建文件写入的目标文件路径
        fw = new FileWriter("C:\\Java\\a.txt");
        // 将文件写入字符缓冲区
        bw = new BufferedWriter(fw);
        // 向缓冲区写入内容
        bw.write("大家好");
        bw.write("我们正在学习Java流");
        // 写入一个换行符
        bw.newLine();
        bw.write("下周二就放寒假了");
        bw.newLine();
        // 刷新缓冲区，将内容写入目标文件
        bw.flush();

        // 创建文件读取的目标文件路径
        fr = new FileReader("C:\\Java\\a.txt");
        // 将文件读取到字符缓冲区
        br = new BufferedReader(fr);
        String str = null;
        // 逐行读取文件内容并打印
        while ((str = br.readLine()) != null) {
            System.out.println(str);
        }

        // 关闭流，释放资源
        fw.close();
        bw.close();
        fr.close();
        br.close();
    }
}