Java IO字符流

字符流

当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储（如："学生"两个字占用了四个字节）。所以Java提供一些字符流类，以字符为单位读写数据专门用于处理文本文件。

字符输入流 —— Reader

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

public void close()
// 关闭此流并释放与此流相关联的任何系统资源。

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

public int read(char[] chars)
// 从输入流中读取一些字符，并将它们存储到字符数组chars中。

FileReader类

java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

构造方法：

FileReader(File file)
// 刨建一个新的FileReader，给定要读取的File对象。

Filereader( String filename)
// 创建一个新的 FileReader，给定要读取的文件的名称。

举例：

字符输入流Reader，类似于字节输入流InputStream。字符输入流一单个字符为单位，字节输入流以一个字节为单位。

/**
 * 字符输入流使用步骤：
 * 1、创建FileReader对象，构造方法中绑定要读取的数据源
 * 2、使用FileReader对象中的方法read，读取文件
 * 3、释放资源
 */

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

public class DemoFileReader {
    public static void main(String[] args) throws IOException {
        // 创建FileReader对象，构造方法中绑定要读取的数据源
        FileReader fr = new FileReader("/Users/liyihua/IdeaProjects/Study/src/view/study/demo31/A");

        // 使用FileReader对象中的方法read，读取文件
        int len = 0;
        while ((len = fr.read()) != -1) {
            System.out.println((char) len);
        }

        // 释放资源
        fr.close();
    }
}

文件A里面的内容：

 控制台输出：

零
一
二
三
四
五
六
七
八
九
十

字符输出流 —— Writer

java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信思写出到目的地。它定义了字节输出流的基本共性功能方法。

public void write(int c)
// 写入单个字符。

public void write(char cbuf[])
// 写入字符数组。

abstract public void write(char cbuf[], int off, int len)
// 写入字符数组的某一部分，off是数组的开始索引，len是写的字符个数。

public void write(String str)
// 写入字符串。

public void write(String str, int off, int len)
//写入字符的某一部分。off是字符的开始素，len是写的字符个数。

abstract public void flush()
// 刷新该流的缓冲。

abstract public void close()
// 关闭此流，但要先刷新它。

FileWriter类

java.io.FileWriter类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

字符输出流的使用步骤：

1. 创建FileWriter对象，构造方法中绑定要写入数据的目的地。
2. 使用 FileWriter中的方法write把数据写入到内存缓冲区中（字符转换为字节的过程）
3. 使用FileWriter中的方法flush，把内存缓冲区中的数据刷新到文件中。
4. 释放资源（会先把内存冲区中的数据刷新到文件中）。

import java.io.IOException;
import java.io.FileWriter;

public class DemoFileWriter {
    public static void main(String[] args) throws IOException {
        // 1.创建FileWriter对象，构造方法中绑定要写入数据的目的地。
        FileWriter fw = new FileWriter("/Users/liyihua/IdeaProjects/Study/src/view/study/demo31/test.txt");

        // 2.使用FileWriter中的方法write把数据写入到内存缓冲区中（字符转换为字节的过程）。
        fw.write("Hello FileWriter");

        // 3.使用FileWriter中的方法flush，把内存缓冲区中的数据刷新到文件中。
        fw.flush();

        // 4.释放资源（会先把内存冲区中的数据刷新到文件中）。
        fw.close();
    }
}

关闭和刷新

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

1. flush：刷新绶冲区，流对象可以继续使用。
2. close：先刷新绶冲区，然后通知系统释放资源。流对象不可以再被使用了。

如上个例子，在使用了flush()方法后可以继续使用write方法，而在使用了close()方法后，就不可以继续使用write方法了，否则在运行期会抛出错误。

写出其他数据

write(char cbuf[])方法和write(char cbuf[], int off, int len)方法，每次可以写出字符数组的数据，即将字符数组中的数据写入到文件中去。

import java.io.FileWriter;
import java.io.IOException;

public class Demo1FileWriter {
    public static void main(String[] args) throws IOException {

        FileWriter fw = new FileWriter("/Users/liyihua/IdeaProjects/Study/src/view/study/demo31/write1.txt");

        char[] chars = "编程路上的小学生".toCharArray();

        fw.write(chars);

        char[] chars1 = {97, 98, 99};
        
        fw.write(chars1, 0, 2);

        fw.flush();

        fw.close();
    }
}

运行结果：

续写与换行

操作类似于FileOutputStream

import java.io.FileWriter;
import java.io.IOException;

public class DemoAppendAddLindWrite {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("/Users/liyihua/IdeaProjects/Study/src/view/study/demo31/test2.txt", true);

        fw.write("工程师");

        fw.write("
");

        fw.write("程序员");

        fw.flush();

        fw.close();
    }
}

程序运行两次：

IO异常的处理

import java.io.FileWriter;
import java.io.IOException;

public class DemoFileWriteTryCatch {
    public static void main(String[] args) {
        // 创建FileWriter并赋值Null
        FileWriter fw = null;
        try {
            // 创建FileWriter对象
            fw = new FileWriter("/Users/liyihua/IdeaProjects/Study/src/view/study/demo31/test3.txt", true);

            // 写入数据
            fw.write("处理异常测试输入1");
            fw.write("
");
            fw.write("处理异常测试输入2");

            // 刷新
            fw.flush();
        } catch (IOException e) {
            // 自己处理异常
            System.out.println(e.getMessage());
        } finally {
            // 无论咋滴，最后都释放资源
            try {
                // 关闭，当且仅当fw != null的时候
                assert fw != null;
                fw.close();
            } catch (IOException e) {
                // 自己处理异常
                System.out.println(e.getMessage());
            }
        }
    }
}

运行两次结果：

在JDK7后，可以直接在try后创建流对象，而不用写finally语句块，最后也会释放资源（自动释放资源）。

格式：

try (定义流对象1; 定义流对象2.....) {
    可能会出现异常的代码块
} catch (异常变量 变量名) {
    异常的逻辑
}

举例（文件复制）：

// 没使用try...catch

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 文件复制的步骤：
 * 1.创建一个字节输入流对象，构造方法中绑定要读取的数据源。
 * 2.创建一个字节输出流对象，构造方法中绑定要写入的目的地。
 * 3.使用字节输入流对象中的方法read读取文件。
 * 4.使用字节输出流中的方法write，把读取到的字节写入到目的地的文件中。
 * 5.释放资源。
 */
public class Demo01CopyFile {
    public static void main(String[] args) throws IOException {
        // 创建一个字节输入流对象，构造方法中绑定要读取的数据源。
        FileInputStream fis = new FileInputStream("/Users/liyihua/IdeaProjects/Study/src/view/study/demo30/666.jpg");

        // 创建一个字节输出流对象，构造方法中绑定要写入的目的地。
        FileOutputStream fos = new FileOutputStream("/Users/liyihua/IdeaProjects/Study/src/view/study/demo30/999.jpg");

        // 使用字节输入流对象中的方法read读取文件。
        int len = 0;
        while ((len = fis.read()) != -1) {
            // 使用字节输出流中的方法write，把读取到的字节写入到目的地的文件中。
            fos.write(len);
        }

        // 释放资源。
        fis.close();
        fos.close();
    }
}

// 使用try...catch
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoJDK7 {
    public static void main(String[] args) {

        try (
                FileInputStream fis = new FileInputStream("/Users/liyihua/IdeaProjects/Study/src/view/study/demo31/666.jpg");
                FileOutputStream fos = new FileOutputStream("/Users/liyihua/IdeaProjects/Study/src/view/study/demo31/999.jpg");
                ) {
            int len = 0;
            while ((len = fis.read()) != -1) {
                fos.write(len);
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

运行两个程序结果都一样，将文件666.jpg复制为999.jpg