关于java:java学习笔记9IO系统-缓冲流

字节缓冲流

字节缓冲输入流

java.io.BufferedOutputStream extends OutputStream

构造方法：

BufferedOutputStream(OutputStream out):创立一个新的缓冲输入流，将数据写入指定的底层输入流
BufferedOutputStream(OutputStream out, int size)：

参数：
    OutputStream out：字节输入流
    可传递FileOutputStream，缓冲流给FileOutputStream减少一个缓冲区，进步其写入效率
    
    int size：指定缓冲流外部缓冲区大小
    

应用步骤（！！！）

1. 创立FileOutputStream对象，构造方法中绑定输入目的地
2. 创立BufferedOutputStream对象，构造方法中传递FileOutputStream对象，进步FileOutputStream对象效率
3. 应用BufferedOutputStream对象中write办法，将数据写入到外部缓冲区
4. 应用BufferedOutputStream对象中flush办法，把外部缓冲区的数据，刷新到文件中
5. 开释资源（先调用flush，再close）

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("E:\\A JI\\program\\java\\g.txt");

        BufferedOutputStream bos = new BufferedOutputStream(fos);

        bos.write("把数据写入缓冲区".getBytes());
        bos.flush();
        bos.close();
    }

字节缓冲输出流

java.io.BufferedIntputStream extends InputStream

构造方法：

BufferedInputStream(InputStream in):创立一个新的缓冲输出流，将数据写入指定的底层输入流
BufferedInputStream(InputStream in, int size)：

参数：
    InputStream in：字节输入流
    可传递FileInputStream，缓冲流给FileInputStream减少一个缓冲区，进步其读取效率
    
    int size：指定缓冲流外部缓冲区大小

应用步骤（！！！）

1. 创立FileInputStream对象，构造方法中绑定要读取的数据源
2. 创立BufferedInputStream对象，构造方法中传递FileInputStream对象，进步FileInputStream对象读取效率
3. 应用BufferedInputStream对象中read办法，读取文件
4. 开释资源

    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("E:\\A JI\\program\\java\\g.txt");

        BufferedInputStream bis = new BufferedInputStream(fis);

        byte[] bytes = new byte[1024];
        int len = 0;
        while((len = bis.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }
        bis.close();
    }

字符缓冲流

字符缓冲输入流

java.io.BufferedWriter extends Writer

构造方法：

BufferedWriter(Writer out):创立一个新的缓冲字符输入流
BufferedWriter(Writer out, int size)：

参数：
    Writer out：字符输入流
    可传递FileWriter，缓冲流给FileWriter减少一个缓冲区，进步其写入效率
    
    int size：指定缓冲流外部缓冲区大小

特有成员办法：

void newLine()：写入一个行分隔符，会主动依据不同的操作系统，获取不同的航分隔符

应用步骤（！！！）

1. 创立字符缓冲输入流对象，构造方法中传递字符输入流
2. 应用BufferedWriter对象中write办法，将数据写入到外部缓冲区
3. 应用BufferedWriter对象中flush办法，把外部缓冲区的数据，刷新到文件中
4. 开释资源

    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\A JI\\program\\java\\g.txt"));

        for (int i = 0; i < 10; i++) {
            bw.write("123");
            bw.newLine();
        }

        bw.flush();
        bw.close();
    }

字符缓冲输出流

java.io.BufferedReader extends Reader

构造方法：

BufferedReader(Reader in):创立一个新的缓冲字符输出流
BufferedReader(Reader in, int size)：

参数：
    Reader in：字节输入流
    可传递FileReader，缓冲流给FileReader减少一个缓冲区，进步其读取效率
    
    int size：指定缓冲流外部缓冲区大小

特有的成员办法：

String readLine():读取数据的 行 终止符号

返回值：
    包含该行内容的字符串，不蕴含任何**行终止符**，若达到流开端，**则返回null**（while条件此处有变动）

应用步骤（！！！）

1. 创立FileReader对象，构造方法中绑定要读取的数据源
2. 创立BufferedReader对象，构造方法中传递FileReader对象，进步FileReader对象读取效率
3. 应用BufferedReader对象中read/readLine办法，读取文件
4. 开释资源

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("E:\\A JI\\program\\java\\g.txt"));

        String line;
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }

案例

文本排序！！！！

    public static void main(String[] args) throws IOException {
        HashMap<String, String> map = new HashMap<>();

        BufferedReader br = new BufferedReader(new FileReader("E:\\A JI\\program\\java\\g.txt"));

        BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\A JI\\program\\java\\out.txt"));
        //应用readLine，逐行读取文本
        String line;
        while((line = br.readLine()) != null) {
            //对文本进行切割，能够依据 . 来切割
            //  . 是一个转义字符，须要两个\示意一个一般的 .
            String[] arr = line.split("\\.");
            //将切割好的序号和文本内容存储到HashMap中，key序号有序，会主动排序
            map.put(arr[0], arr[1]);
        }

        //遍历HashMap，获取每一个键值对
        for (String key : map.keySet()) {
            String value = map.get(key);
            //把每一个键值对，拼接成一个文本行
            line = key + "." + value;
            //将拼接好的文本，写入文件
            bw.write(line);
            bw.newLine(); //写一个换行
        }

        bw.flush();
        bw.close();
    }