字符流
当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储（如："学生"两个字占用了四个字节）。所以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类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
字符输出流的使用步骤：
- 创建FileWriter对象，构造方法中绑定要写入数据的目的地。
- 使用 FileWriter中的方法write把数据写入到内存缓冲区中（字符转换为字节的过程）
- 使用FileWriter中的方法flush，把内存缓冲区中的数据刷新到文件中。
- 释放资源（会先把内存冲区中的数据刷新到文件中）。
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方法了。
- flush：刷新绶冲区，流对象可以继续使用。
- 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("\\n");
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("\\n");
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