【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毫秒，速度提升了六倍還多！！！