Java基础（26）字符流、字符流便捷类、高效的字符流

1. 字符流

1. 字符流的概述：由于字节流操作中文不是很方法，于是Java提供了字符流

2. 字符流 = 字节流 + 编码表

3. 编码与解码
（1）编码：按照某种编码方式把字符串数组转换成字节数组（看得懂 --> 看不懂）
（2）解码：把字节数组按照某种编码方式转换成字符串（看不懂 --> 看不懂）

public class TestDemo01 {
    public static void main(String[] args) {
        String str = "英雄联盟 影流";

        //使用默认编码表对字符串进行编码
        byte[] bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes));  //[-24, -117, -79, -23, -101, -124, -24, -127, -108, -25, -101, -97, 32, -27, -67, -79, -26, -75, -127]

        //使用默认编码表对字节数组进行解码
        String newStr = new String(bytes);
        System.out.println(newStr);   //英雄联盟 影流
    }
}

4. 字符流的继承关系

5. OutputStreamWriter：字符输出流

（1）OutputStreamWriter概述：OutputStreamWriter 是字符流通向字节流的桥梁。可使用指定的码表将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集

（2）构造方法

	OutputStreamWriter(OutputStream out)：创建使用默认字符编码的 OutputStreamWriter
    OutputStreamWriter(OutputStream out, String charsetName)：创建使用指定字符集的 OutputStreamWriter。String charsetName：编码表

public class TestDemo02 {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter(OutputStream out)：创建使用默认字符编码的 OutputStreamWriter
        OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream("a.txt"));

        //OutputStreamWriter(OutputStream out, String charsetName)：创建使用指定字符集的 OutputStreamWriter。String charsetName：编码表
        OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("b.txt"),"UTF-8");

    }
}

（3）OutputStreamWriter的5种写数据的方式

	public void write(int c)：写一个字符
	public void write(char[] cbuf)：写一个字符数组
	public void write(char[] cbuf,int off,int len)：写一个字符数组的 一部分
	public void write(String str)：写一个字符串
	public void write(String str,int off,int len)：写一个字符串的一部分

public class TestDemo03 {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"));

        //public void write(int c)：写一个字符
        osw.write('A');
        osw.write("\r\n");

        //public void write(char[] cbuf)：写一个字符数组
        osw.write(new char[] {'英','雄','联','盟','巨','神','峰'});
        osw.write("\r\n");

        //public void write(char[] cbuf,int off,int len)：写一个字符数组的 一部分
        osw.write(new char[] {'英','雄','联','盟','巨','神','峰'},0,4);
        osw.write("\r\n");

        //public void write(String str)：写一个字符串
        osw.write("爱生活，爱Java");
        osw.write("\r\n");

        //public void write(String str,int off,int len)：写一个字符串的一部分
        osw.write("UZI，永远滴神",0,3);
        osw.write("\r\n");

        //使用字符流之后，一定要记得刷新
        osw.flush();

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

    /**
     * A
     * 英雄联盟巨神峰
     * 英雄联盟
     * 爱生活，爱Java
     * UZI
     */
}

（4）OutputStreamWriter的追加写入

public class TestDemo04 {
    public static void main(String[] args) throws IOException {
        //如果要追加写入的话，在FileOutputStream后面加true即可
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt", true));

        osw.write("UZI,永远滴神");
        osw.write("\r\n");
        //记得刷新
        osw.flush();
        //释放资源
        osw.close();

        /**
         * 运行三次后的结果：
         * UZI,永远滴神
         * UZI,永远滴神
         * UZI,永远滴神
         */

    }
}

6. InputStreamReader：字符输入流

（1）InputStreamReader概述：是字节流通向字符流的桥梁。它使用指定的码表读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集

（2）构造方法

	InputStreamReader(InputStream is)：用默认的编码(GBK)读取数据
	InputStreamReader(InputStream is,String charsetName)：用指定的编码读取数据

public class TestDemo01 {
    public static void main(String[] args) throws IOException {
        //InputStreamReader(InputStream is):用默认的编码(GBK)读取数据
        InputStreamReader isr1 = new InputStreamReader(new FileInputStream("a.txt"));

        //InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据
        InputStreamReader isr2 = new InputStreamReader(new FileInputStream("a.txt"),"UTF-8");
    }
}

（3）InputStreamReader的2种读数据的方式

	public int read()：一次读取一个字符
	public int read(char[] cbuf)：一次读取一个字符数组 如果没有读到 返回-1

/**
 * a.txt:
 * A
 * 英雄联盟巨神峰
 * 英雄联盟
 * 爱生活，爱Java
 * UZI
 */

========================================================================
public class TestDemo02 {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));

        //public int read()：一次读取一个字符
        //如果读取不到，就返回-1 我们就可以使用 -1 来判断这个文件是否读取完毕
        int i = isr.read();
        System.out.println((char)i);  //A

        i = isr.read();
        System.out.println(i);   //13(回车)

        i = isr.read();
        System.out.println(i);   //10(换行)

        i = isr.read();
        System.out.println((char)i);   //英

        i = isr.read();
        System.out.println((char) i);   //雄

        isr.close();
    }
}

========================================================================

public class TestDemo03 {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));

        //public int read(char[] cbuf)：一次读取一个字符数组 如果没有读到 返回-1

        //定义一个字符数组充当容器，可以一次取到这个容器中
        char[] chars = new char[1024 * 8];
        int len = isr.read(chars);

        System.out.println(len);  //34
        System.out.println(Arrays.toString(chars));

        String str = new String(chars);
        System.out.println(str);
        /**
         * A
         * 英雄联盟巨神峰
         * 英雄联盟
         * 爱生活，爱Java
         * UZI
         */

        isr.close();
    }
}

7. OutputStreamWriter + InputStreamReader 复制文件

（1）一次读写一个字符来复制【效率低】

public class TestDemo01 {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("newA.txt"));

        int ch = 0;
        while ((ch = isr.read()) != -1){
            osw.write(ch);
            osw.flush();
        }

        isr.close();
        osw.close();
    }
}

（2）一次读写一个字符数组来复制【效率高】

public class TestDemo02 {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("b.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("newB.txt"));

        char[] chars = new char[1024 * 8];

        int len = 0;
        while ((len = isr.read(chars)) != -1){
            osw.write(chars,0,len);
            osw.flush();
        }

        isr.close();
        osw.close();
    }
}

2. 字符流便捷类

1. 字符流便捷类概述：因为字符转换流的名字太长了，并且在一般情况下我们不需要制定字符集，于是Java就给我们提供转换流对应的便捷类

2. 字符流便捷类的继承关系

		父类---------------------子类
        InputStreamReader------FileReader
        OutputStreamWriter-----FileWriter

3. 构造方法和成员方法

（1）构造方法

	FileReader(String fileName)：在给定从中读取数据的文件名的情况下创建一个新 FileReader。
    FileReader(File file)：在给定从中读取数据的 File 的情况下创建一个新 FileReader
===================================================================
	FileWriter(File file)：根据给定的 File 对象构造一个 FileWriter 对象。
    FileWriter(String fileName)：根据给定的文件名构造一个 FileWriter 对象。
    FileWriter(String fileName, boolean append)：根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象

（2）成员方法：完全继承自 InputStreamReader和OutputStreamWriter

public class TestDemo01 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("a.txt");
        FileWriter fw = new FileWriter("newAA.txt");

        char[] chars = new char[1024 * 8];
        int len = 0;

        while ((len = fr.read(chars)) != -1){
            fw.write(chars,0,len);
            fw.flush();
        }

        fr.close();
        fw.close();
    }
}

3. 高效的字符流

1. 高效的字符流概述：
（1）BufferedWriter写出数据：高效的字符输出流
（2）BufferedReader读取数据：高效的字符输入流

2. 构造方法及成员方法

（1）构造方法

	public BufferedWriter(Writer w)：高效的字符输出流
	public BufferedReader(Reader e)：高效的字符输入流

（2）成员方法：继承自InputStreamReader和OutputStreamWriter

public class TestDemo01 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("b.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("newBB.txt"));

        char[] chars = new char[1024 * 8];
        int len = 0;
        
        while ((len = br.read(chars)) != -1){
            bw.write(chars,0,len);
            bw.flush();
        }

        br.close();
        bw.close();
    }
}

3. 特有的方法

	BufferedWriter：public void newLine()：根据系统来决定换行符，具有系统兼容性的换行符
	BufferedReader：public String readLine()：一次读取一行数据，是以换行符为标记的，读到换行符就换行，没读到数据返回null

public class TestDemo02 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("c.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("newC.txt"));

        //循环的进行读取一行，写入一行
        //一行一行读取，读取不到返回的是null
        String line = null;
        while ((line = br.readLine()) != null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        br.close();
        bw.close();
    }
}