java IO流之字符流 v_1.0.0

说明：本文是基础知识，供入门者参考。

字符流：读取的是字符。分为输入流和输出流。
Reader：字符输入流，是一个抽象类。是所有字符输入流的超类。
Writer：字符输出流，是一个抽象类。是所有字符输出流的超类。

1.Reader 之 FileReader

常用方法：
int read()
读取单个字符。返回作为整数读取的字符，范围在 0 到 65535 之间 ( 0x00-0xffff)，如果已到达流的末尾，则返回 -1。
int read(char[] cbuf)
将字符读入数组。返回读取的字符数，如果已到达流的末尾，则返回 -1。
int read(char[] cbuf, int off, int len)
将字符读入数组的某一部分。返回读取的字符数，如果已到达流的末尾，则返回 -1
long skip(long n)
跳过字符。
void close()
关闭该流并释放与之关联的所有资源。

    @Test
    public void testReader() throws IOException {
        //hello.txt中存储的是abcdefg
        //构造方法
        //FileReader(File file)
        //FileReader(String name)
        FileReader reader = new FileReader("D:\\hello.txt");
        System.out.println("---------1--------");
        while(true) {
            //一次读取一个字符
            int c = reader.read();
            if(c== -1) {
                break;
            }
            System.out.println(c);
        }
        reader.close();
        //运行结果
        /*
        ---------1--------
        97
        98
        99
        100
        101
        102
        103
        */

        System.out.println("---------2--------");
        FileReader reader1 = new FileReader("D:\\hello.txt");
        while(true) {
            //一次读取多个字符并将读取到的字符放入一个字符数组中。
            char[] chars = new char[10];
            int len = reader1.read(chars);
            if(len == -1) {
                break;
            }
            System.out.println(len);
            System.out.println(Arrays.toString(chars));
        }
        reader1.close();
        //运行结果
        /*
        ---------2--------
        7
        [a, b, c, d, e, f, g, 
        */

        System.out.println("---------3--------");
        FileReader reader2 = new FileReader("D:\\hello.txt");
        while(true) {
            //一次读取多个字符并将读取到的字符放入一个字符数组中。
            char[] chars = new char[10];
            int len = reader2.read(chars, 2, 8);
            if(len == -1) {
                break;
            }
            System.out.println(len);
            System.out.println(Arrays.toString(chars));
        }
        reader2.close();
        //运行结果
        /*
        ---------3--------
        7
        [ ， ，a, b, c, d, e, f, g, ]
        */

        System.out.println("---------4--------");
        FileReader reader3 = new FileReader("D:\\hello.txt");
        while(true) {
            char[] chars = new char[3];
            int len = reader3.read(chars);
            if(len == -1) {
                break;
            }
            reader3.skip(2);
            System.out.println(Arrays.toString(chars));
            System.out.println(len);
        }
        reader3.close();
        //运行结果
        /*
        ---------4--------
        [a, b, c]
        3
        [f, g, ]
        2
        */
    }

2.Writer 之 FileWriter

常用方法：
Writer append(char c)
将指定字符添加到此 writer。
void write(int c)
写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，即0~65535之间。
void write(char[] cbuf)
写入字符数组。
void write(char[] cbuf, int off, int len)
写入字符数组的某一部分。
void write(String str)
写入字符串。
void write(String str, int off, int len)
写入字符串的某一部分。
void close()
关闭此流，但要先刷新它。
void flush()
刷新该流的缓冲。

    @Test
    public void testWriter() throws IOException {
        FileWriter out = new FileWriter("D:\\helloworld.txt",true);
        char c = 'a';
        //以下两个方法的效果是相同的。都可以写出一个字符。
        out.append(c);//写出 a
        out.write(c);//写出 a

        //写出一个字符数组
        char[] chars = {'a','b','c','d'};
        out.write('-');//写出 -
        out.write(chars);//写出 abcd
        //写出一个字符数组的一部分
        out.write('-');//写出 -
        out.write(chars, 2, 2);//写出 cd

        //写出一个字符串
        String str = "abcd";
        out.write('-'); //写出 -
        out.write(str); //写出 abcd
        //写出一个字符串的一部分
        out.write('-'); //写出 -
        out.write(str,2,2); //写出 cd

        out.close();

    }

3.BufferedReader 字符缓冲输入流

构造方法：

BufferedReader(Reader reader)
BufferedReader(Reader reader, int size) size缓冲区大小

常用方法：
void close()
关闭该流并释放与之关联的所有资源。
int read()
读取单个字符。
int read(char[] cbuf, int off, int len)
将字符读入数组的某一部分。
long skip(long n)
跳过字符。
以上方法与前面一样，在此不重复了。
String readLine()
读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (‘\n’)、回车 (‘\r’) 或回车后直接跟着换行。
返回包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。

    @Test
    public void testBufferedReader() throws IOException {
        FileReader reader = new FileReader("D:\\helloworld.txt");
        BufferedReader buffR = new BufferedReader(reader);
        while(true) {
            String str = buffR.readLine();//读到末尾，则返回null.
            if(str == null) {
                break;
            }
            System.out.println(str);
        }
        buffR.close();
    }

4.BufferedWriter 字符缓冲流之输出流

构造方法：

BufferedWriter(Writer out) 
          创建一个使用默认大小输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz) 
          创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

常用方法：
void close()
关闭此流，但要先刷新它。
void flush()
刷新该流的缓冲。
void write(char[] cbuf, int off, int len)
写入字符数组的某一部分。
void write(int c)
写入单个字符。
void write(String s, int off, int len)
写入字符串的某一部分。
//以上方法参考前面。

void newLine()
写入一个行分隔符。

    @Test
    public void testBufferedWriter() throws IOException {
        FileWriter writer = new FileWriter("D:\\hello.txt",true);
        BufferedWriter buffW = new BufferedWriter(writer);
        String s1 = "ab";
        buffW.write(s1);
        buffW.newLine();//起一个换行的作用。
        buffW.write(s1);
        buffW.close();
    }