一、java.io.Reader

字符输入流，是一个抽象类，是字符输入流的最顶层父类

共性的方法：

方法	作用
int read()	读取单个字符并且返回
int read(char[] cbuf)	一次读取多个字符，存储进数组里
void close()	关闭该流，并释放所有与之关联的资源

java.io.FileReader,Reader字符输入流的一个子类

java.io.FileReader extends InputStreamReader extends Reader

文件字符输入流，按照字符而不是按照字节读入

构造方法：

构造方法	作用
FileReader(String fileName)	fileName文件的路径，创建一个FileReader对象，把该对象指向要读取的文件
FileReader(File file)	file文件对象，创建一个FileReader对象，把该对象指向要读取的文件

// 文件读取的过程和字节文件输入流类似
package cn.zhuobo.day14.filereader;

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

public class Demo01FileReader {
    public static void main(String[] args) throws IOException {
        File file = new File("/home/zhuobo/Desktop/dir/a.txt");
        FileReader fr = new FileReader(file);

        /*int len = 0;
        while((len = fr.read()) != -1) {
            System.out.println((char)len);
        }*/
        char[] chars = new char[1024];
        int len = 0;
        while ((len = fr.read()) != -1) {
            System.out.println(new String(chars, 0, len));
        }
        fr.close();
    }
}

二、java.io.Writer

字符输出流，是一个抽象类，是字符输出流的最顶层父类

共性的方法：

方法	作用
void write(int c)	写入单个字符
void write(char[] cbuf)	写入字符数组
abstract void write(char[] cbuf, int off, int len)	写入字符数组的某一部分，索引off开始，len的长度
void write(String str)	写入字符串
void write(String str, int off, int len)	写入字符串的某个部分
void flush()	刷新该流的缓冲
void close()	关闭流，释放资源

java.io.FileWriter, Writer的一个子类

java.io.FileWriter extends OutputStreamWriter extends Writer

文件输出流，按照字符来输出，而不是按照字节

构造方法

构造方法	作用
FileWriter(File file)	根据给定File对象构造一个FileWriter对象，创建一个文件，将FileWriter对象指向文件
FileWriter(String filename)	根据给定文件名(文件路径)，构造一个FileWriter对象，创建一个文件，将FileWriter对象指向文件
FileWriter(File file, boolean append)	有续写开关的版本，append == true，不会创建新文件覆盖源文件
FileWriter(String filename， boolean append)	有续写开关的版本，append == true，不会创建新文件覆盖源文件

字符输出流写入文件的步骤：

创建FileWriter对象，构造方法中绑定要写入数据文件的目的地
使用FileWriter对象的write方法，把指定的数据写入到内存缓冲区（有一个字符转换为字节的过程）
使用FileWriter对象的flush方法，把内存缓冲区的数据刷新到文件（这一点与文件字节输出流有所不同）
调用close方法，关闭流，释放资源

flush是刷新缓冲区，流还可以继续使用，可以继续调用write方法继续写入，其实调用close之后，缓冲区也是回刷新到文件，但是流就不能继续使用了。

package cn.zhuobo.day14.aboutfileWriter;

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

public class Demo01FileWriter {
    public static void main(String[] args) throws IOException {
        FileWriter fileWriter = new FileWriter("/home/zhuobo/Desktop/dir/a.txt");

        fileWriter.write(78);// 写单个字节
        fileWriter.flush();

        char[] chars = {'a', 'b', 'c', 'd'};
        fileWriter.write(chars);
        fileWriter.flush();// 写字符数组

        fileWriter.write(chars, 2, 2);// 写一部分的字符数组

        fileWriter.write("你好\n");// 写字符串,并且换行

        fileWriter.close();
    }
}

三、使用try catch finally处理流中的意向

try{
    可能有异常的代码
}catch {
    异常的处理逻辑
}finall {
    close()// close方法放在finally，那么最后一定会关闭流，释放资源
}

package cn.zhuobo.day14.aboutfileWriter;

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

public class Demo01FileWriter {
    public static void main(String[] args) throws IOException {
        FileWriter fileWriter = null;
        try{
            fileWriter = new FileWriter("/hoe/zhuobo/Desktop/dir/a.txt");
            fileWriter.write("sdfa");
        }catch (IOException e) {
            System.out.println(e);
        }finally {
            if(fileWriter != null) {
                fileWriter.close();
            }
        }
    }
}

JDK7的特性：但是当使用下面的写法（try后面加括号，里面定义对象,可以定义多个，分号间隔），这样回自动释放流，不用写finally,以及finally块里的close代码

try(FileWriter fw = new FileWriter("path......");object2......){
    可能有异常的代码
}catch {
    异常的处理逻辑
}

JDK9的特性：上一中的代码格式中，对象的定义可以在try之外，try的括号里面写定义好的对象即可

FileWriter fw = new FileWriter("path......")；
FileReader fr = newFileReader("path......");
try(fr; fw){
    可能有异常的代码
}catch {
    异常的处理逻辑
}

文件字符输入输出流