【Java】第三十八节 IO流之缓冲流

缓冲流

为了提高数据读写的速度，Java API提供了带缓冲功能的缓冲流，在使用这些流类时，会创建一个内部缓冲区数组，缺省使用8192个字节(8Kb)的缓冲区。
缓冲流属于处理流，用来操作节点流，缓冲流有：BufferedReader和BufferedWriter、BufferedInputStream和BufferedOutputStream

• 缓冲流的常用方法与节点流类似；
• 向流中写入字节时，不会直接写到文件，先写到缓冲区中直到缓冲区写满， BufferedOutputStream才会把缓冲区中的数据一次性写到文件里；
• 使用方法 flush()可以强制将缓冲区的内容全部写入输出流，但是一般不使用，因为其内部会自动调用该方法；
• 关闭流的顺序和打开流的顺序相反；
• 只要关闭最外层流即可，关闭最外层流也 会相应关闭内层节点流；
• 在关闭之前还会默认调用一次flush()将缓冲区剩余的数据全部写入输出流。

例：BufferedReader和BufferedWriter

统计上篇博客的例子生成的文本文件“Hello-copy.txt”中各个字符出现的次数，并将结果写入“Hello-counts.txt”文件

package cn.jingpengchong.io;

import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        Map<Character,Integer> map = new HashMap<>();
        //1、创建File类对象
        File srcfile = new File("Hello.txt");
        File desfile = new File("Hello-counts.txt");
        //2、创建BufferedReader/BufferedWriter类对象
        BufferedReader reader = null;
        BufferedWriter writer = null;
        try {
            reader = new BufferedReader(new FileReader(srcfile));
            writer = new BufferedWriter(new FileWriter(desfile));
            char[] data = new char[10];
            //3、读入与写出操作
            int read = reader.read(data);
            while (read != -1){
                for (int i = 0; i < read; i++) {
                    if(map.get(data[i]) == null){
                        map.put(data[i],1);
                    }else{
                        map.put(data[i],map.get(data[i])+1);
                    }
                }
                read = reader.read(data);
            }
            Set<Map.Entry<Character, Integer>> entries = map.entrySet();
            for(Map.Entry<Character, Integer> entry : entries){
                switch (entry.getKey()){
                    case ' ':
                        writer.write("空格\t=\t" + entry.getValue());
                        break;
                    case '\t':
                        writer.write("tab键\t=\t" + entry.getValue());
                        break;
                    case '\r':
                        writer.write("回车\t=\t" + entry.getValue());
                        break;
                    case '\n':
                        writer.write("换行\t=\t" + entry.getValue());
                        break;
                    default:
                        writer.write(entry.getKey() + "\t=\t" + entry.getValue());
                        break;
                }
                writer.newLine();
            }
            System.out.println("统计完成！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(writer != null){
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果如下：

“Hello-counts.txt”文件如下：

例：BufferedInputStream和BufferedOutputStream

用缓冲流实现上篇博客中拷贝视频文件的操作，并比较两次操作消耗的时间长短

package cn.jingpengchong.io;

import java.io.*;

public class Test {
    public static void main(String[] args) {
        //1、创建File类对象
        File srcfile = new File("C:\\Users\\lenovo\\Desktop\\01-视频.avi");
        File desfile = new File("C:\\Users\\lenovo\\Desktop\\02-视频.avi");
        //2、创建BufferedInputStream/BufferedOutputStream类对象
        BufferedInputStream reader = null;
        BufferedOutputStream writer = null;
        try {
            reader = new BufferedInputStream(new FileInputStream(srcfile));
            writer = new BufferedOutputStream(new FileOutputStream(desfile));
            byte[] data = new byte[1024];
            //3、读入与写出操作
            long start = System.currentTimeMillis();
            int read = reader.read(data);
            while (read != -1) {
                writer.write(data, 0, read);
                read = reader.read(data);
            }
            long end = System.currentTimeMillis();
            System.out.println("复制成功！！！用时(毫秒)：" + (end - start));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //4、关闭资源
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果如下：

可以看出，在其他条件都一致的情况下，节点流用时5730毫秒，而缓冲流只用了955毫秒，速度提升了六倍还多！！！