关于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();}