帶緩衝的輸入/輸入流

Auci發表於2022-04-08

《零基礎學Java》

  • 帶緩衝的輸入/輸入流

    緩衝是 I/O 的一種效能優化。緩衝流為 I/O 流增加了記憶體緩衝區。

  • BufferedInputStream類 與 BufferedOutputStream類

    BufferedInputStream類 可以對所有InputStream的子類進行緩衝區的包裝，以達到效能的優化。

    BufferedOutputStream類 中的 flush()方法 被用來把緩衝區的位元組寫入到檔案中，並清空快取。

    BufferedInputStream類的構造方法：

    構造方法 介紹
    BufferedInputStream(FileInputStream fileInputStream); 建立一個帶有32個位元組的緩衝輸入流。
    BufferedInputStream(FileInputStream fileInputStream , int size); 按指定的大小來建立緩衝輸入流。

    BufferedOutputStream類的構造方法：

    構造方法 介紹
    BufferedOutputStream(FileOutputStream fileOutputStream); 建立一個帶有32個位元組的緩衝輸出流。
    BufferedOutputStream(FileOutputStream fileOutputStream , int size); 按指定的大小來建立緩衝輸出流。

    BufferedInputStream類 與 BufferedOutputStream類 例項：

    import java.io.*;

public class Demo4 {
    public static void main(String[] args) {
        /**
         * 緩衝位元組輸入流（BufferedInputStream）
         * 特點：提高效率
         */
        File file = new File("C:\\JAVA_API_1.7中文.chm");
        BufferedInputStream bufferedInputStream = null;//建立緩衝位元組流
        FileInputStream fileInputStream = null;
        long stare = System.currentTimeMillis();//獲得當前流開始時的毫秒值
        try {
            fileInputStream=new FileInputStream(file);
            bufferedInputStream = new BufferedInputStream(fileInputStream);//將檔案位元組流包裝成緩衝位元組流
            byte by[] = new byte[1024];//緩衝區位元組陣列（這個緩衝區與Buffered不同）
            while ((bufferedInputStream.read(by))!=-1){//使用緩衝位元組流讀取資料

            }
            long end = System.currentTimeMillis();//獲得當前流結束時的毫秒值
            System.out.println("執行經歷的毫秒數："+(end - stare));

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileInputStream!=null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedInputStream!=null){
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        
        /**
         * 緩衝位元組輸出流（BufferedOutputStream）
         * 特點：提高效率
         */
        File file1 = new File("C:\\Word.txt");
        BufferedOutputStream bufferedOutputStream = null;//建立緩衝位元組輸出流
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream=new FileOutputStream(file1);
            bufferedOutputStream=new BufferedOutputStream(fileOutputStream);//將檔案輸出流包裝到緩衝位元組輸出流

            String str = "深山踏紅葉，耳畔聞鷺鳴。";
            byte by[] = str.getBytes();
            bufferedOutputStream.write(by);
            //<*> 使用緩衝位元組輸出流時，要多進行重新整理操作，避免等待，有資料時就將資料寫入檔案當中 <*>
            bufferedOutputStream.flush();//重新整理（強制將緩衝區資料寫入檔案中，即使緩衝區沒有寫滿）

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedOutputStream!=null){
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

  • BufferedReader類 與 BufferedWriter類

    BufferedReader類 與 BufferedWriter類 分別繼承了 Reader類 與 Writer類，這兩個類同樣具有內部緩衝機制，並以行為單位輸入/輸出。

    BufferedReader類常用方法：

BufferedWriter類常用方法：

BufferedReader類 與 BufferedWriter類 例項：

import java.io.*;

public class Demo6 {
    public static void main(String[] args) {
        File file = new File("C:\\Word.txt");

        /**
         * 檔案緩衝字元輸出流（BufferedWriter）
         */
        FileWriter fileWriter = null;//建立檔案字元輸出流
        BufferedWriter bufferedWriter = null;//建立檔案緩衝字元輸出流

        try {
            fileWriter = new FileWriter(file);
            bufferedWriter = new BufferedWriter(fileWriter);//將檔案字元輸出流包裝成檔案緩衝字元輸出流

            String str1 = "神裡";
            String str2 = "綾華";

            bufferedWriter.write(str1);//第一行資料
            bufferedWriter.newLine();//建立一個新行
            bufferedWriter.write(str2);//第二行資料

        } catch (IOException e) {
            e.printStackTrace();
        }finally {//<*> 注意：流的關閉順序，先建立的後關閉。 <*>
            if (bufferedWriter!=null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileWriter!=null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


        /**
         * 檔案緩衝字元輸入流（BufferedReader）
         */
        FileReader fileReader = null;
        BufferedReader bufferedReader = null;
        try {
            fileReader = new FileReader(file);
            bufferedReader = new BufferedReader(fileReader);//將檔案字元輸入流包裝成檔案緩衝字元輸入流
            String tmp = null;//臨時變數
            int i = 1;//計數器
            while ((tmp = bufferedReader.readLine())!=null){//迴圈讀取檔案中的內容
                System.out.println("第"+i+"行："+tmp);
                i++;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileReader!=null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

相關文章