Java 緩衝流

BufferedOutputStream:字節緩衝輸出流

繼承自父類的共性成員方法:

  • public void close() :關閉此輸出流並釋放與此流相關聯的任何系統資源。
  • public void flush() :刷新此輸出流並強制任何緩衝的輸出字節被寫出。
  • public void write(byte[] b):將 b.length字節從指定的字節數組寫入此輸出流。
  • public void write(byte[] b, int off, int len) :從指定的字節數組寫入 len字節,從偏移量 off開始輸出到此輸出流。
  • public abstract void write(int b) :將指定的字節輸出流。

構造方法:
BufferedOutputStream(OutputStream out) 創建一個新的緩衝輸出流,以將數據寫入指定的底層輸出流。
BufferedOutputStream(OutputStream out, int size) 創建一個新的緩衝輸出流,以將具有指定緩衝區大小的數據寫入指定的底層輸出流。
參數:
OutputStream out:字節輸出流
我們可以傳遞FileOutputStream,緩衝流會給FileOutputStream增加一個緩衝區,提高FileOutputStream的寫入效率
int size:指定緩衝流內部緩衝區的大小,不指定默認

  • 使用步驟(重點)
    1.創建FileOutputStream對象,構造方法中綁定要輸出的目的地
    2.創建BufferedOutputStream對象,構造方法中傳遞FileOutputStream對象對象,提高FileOutputStream對象效率
    3.使用BufferedOutputStream對象中的方法write,把數據寫入到內部緩衝區中
    4.使用BufferedOutputStream對象中的方法flush,把內部緩衝區中的數據,刷新到文件中
    5.釋放資源(會先調用flush方法刷新數據,第4部可以省略)

BufferedInputStream:字節緩衝輸入流

  • 繼承自父類的成員方法:
    • int read()從輸入流中讀取數據的下一個字節。
    • int read(byte[] b) 從輸入流中讀取一定數量的字節,並將其存儲在緩衝區數組 b 中。
    • void close() 關閉此輸入流並釋放與該流關聯的所有系統資源。

構造方法:
BufferedInputStream(InputStream in) 創建一個 BufferedInputStream 並保存其參數,即輸入流 in,以便將來使用。
BufferedInputStream(InputStream in, int size) 創建具有指定緩衝區大小的 BufferedInputStream 並保存其參數,即輸入流 in,以便將來使用。
參數:
InputStream in:字節輸入流
我們可以傳遞FileInputStream,緩衝流會給FileInputStream增加一個緩衝區,提高FileInputStream的讀取效率
int size:指定緩衝流內部緩衝區的大小,不指定默認

使用步驟(重點):
1.創建FileInputStream對象,構造方法中綁定要讀取的數據源
2.創建BufferedInputStream對象,構造方法中傳遞FileInputStream對象,提高FileInputStream對象的讀取效率
3.使用BufferedInputStream對象中的方法read,讀取文件
4.釋放資源

文件複製案例

package com.itheima.demo02.CopyFile;

import java.io.*;

/*
    文件複製練習:一讀一寫

    明確:
        數據源: c:\\1.jpg
        數據的目的地: d:\\1.jpg
    文件複製的步驟:
        1.創建字節緩衝輸入流對象,構造方法中傳遞字節輸入流
        2.創建字節緩衝輸出流對象,構造方法中傳遞字節輸出流
        3.使用字節緩衝輸入流對象中的方法read,讀取文件
        4.使用字節緩衝輸出流中的方法write,把讀取的數據寫入到內部緩衝區中
        5.釋放資源(會先把緩衝區中的數據,刷新到文件中)

    文件的大小:780,831 字節
    一次讀寫一個字節:32毫秒
    使用數組緩衝讀取多個字節,寫入多個字節:5毫秒
 */
public class Demo02CopyFile {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        //1.創建字節緩衝輸入流對象,構造方法中傳遞字節輸入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("c:\\1.jpg"));
        //2.創建字節緩衝輸出流對象,構造方法中傳遞字節輸出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("d:\\1.jpg"));
        //3.使用字節緩衝輸入流對象中的方法read,讀取文件
        //一次讀取一個字節寫入一個字節的方式
        /*int len = 0;
        while((len = bis.read())!=-1){
            bos.write(len);
        }*/

        //使用數組緩衝讀取多個字節,寫入多個字節
        byte[] bytes = new byte[1024];
        int len = 0;
        while((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }

        bos.close();
        bis.close();

        long e = System.currentTimeMillis();
        System.out.println("複製文件共耗時:"+(e-s)+"毫秒");
    }
}

BufferedWriter:字符緩衝輸出流

繼承自父類的共性成員方法:

  • void write(int c) 寫入單個字符。
  • void write(char[] cbuf)寫入字符數組。
  • abstract void write(char[] cbuf, int off, int len)寫入字符數組的某一部分,off數組的開始索引,len寫的字符個數。
  • void write(String str)寫入字符串。
  • void write(String str, int off, int len) 寫入字符串的某一部分,off字符串的開始索引,len寫的字符個數。
  • void flush()刷新該流的緩衝。
  • void close() 關閉此流,但要先刷新它。

構造方法:
BufferedWriter(Writer out) 創建一個使用默認大小輸出緩衝區的緩衝字符輸出流。
BufferedWriter(Writer out, int sz) 創建一個使用給定大小輸出緩衝區的新緩衝字符輸出流。
參數:
Writer out:字符輸出流
我們可以傳遞FileWriter,緩衝流會給FileWriter增加一個緩衝區,提高FileWriter的寫入效率
int sz:指定緩衝區的大小,不寫默認大小

特有的成員方法:
void newLine() 寫入一個行分隔符。會根據不同的操作系統,獲取不同的行分隔符
換行:換行符號
windows:\r\n
linux:/n
mac:/r
使用步驟:
1.創建字符緩衝輸出流對象,構造方法中傳遞字符輸出流
2.調用字符緩衝輸出流中的方法write,把數據寫入到內存緩衝區中
3.調用字符緩衝輸出流中的方法flush,把內存緩衝區中的數據,刷新到文件中
4.釋放資源

public static void main(String[] args) throws IOException {
     //System.out.println();
     //1.創建字符緩衝輸出流對象,構造方法中傳遞字符輸出流
     BufferedWriter bw = new BufferedWriter(new FileWriter("10_IO\\c.txt"));
     //2.調用字符緩衝輸出流中的方法write,把數據寫入到內存緩衝區中
     for (int i = 0; i <10 ; i++) {
         bw.write("傳智播客");
         //bw.write("\r\n");
         bw.newLine();
     }
     //3.調用字符緩衝輸出流中的方法flush,把內存緩衝區中的數據,刷新到文件中
     bw.flush();
     //4.釋放資源
     bw.close();
}

#BufferedReader:字符緩衝輸入流

繼承自父類的共性成員方法:

  • int read() 讀取單個字符並返回。
  • int read(char[] cbuf)一次讀取多個字符,將字符讀入數組。
  • void close() 關閉該流並釋放與之關聯的所有資源。

構造方法:
BufferedReader(Reader in) 創建一個使用默認大小輸入緩衝區的緩衝字符輸入流。
BufferedReader(Reader in, int sz) 創建一個使用指定大小輸入緩衝區的緩衝字符輸入流。
參數:
Reader in:字符輸入流
我們可以傳遞FileReader,緩衝流會給FileReader增加一個緩衝區,提高FileReader的讀取效率
特有的成員方法:
String readLine() 讀取一個文本行。讀取一行數據
行的終止符號:通過下列字符之一即可認爲某行已終止:換行 (’\n’)、回車 (’\r’) 或回車後直接跟着換行(\r\n)。
返回值:
包含該行內容的字符串,不包含任何行終止符,如果已到達流末尾,則返回 null

使用步驟:
1.創建字符緩衝輸入流對象,構造方法中傳遞字符輸入流
2.使用字符緩衝輸入流對象中的方法read/readLine讀取文本
3.釋放資源

public static void main(String[] args) throws IOException {
        //1.創建字符緩衝輸入流對象,構造方法中傳遞字符輸入流
        BufferedReader br = new BufferedReader(new FileReader("10_IO\\c.txt"));

        //2.使用字符緩衝輸入流對象中的方法read/readLine讀取文本
        /*String line = br.readLine();
        System.out.println(line);

        line = br.readLine();
        System.out.println(line);

        line = br.readLine();
        System.out.println(line);

        line = br.readLine();
        System.out.println(line);*/

        /*
            發下以上讀取是一個重複的過程,所以可以使用循環優化
            不知道文件中有多少行數據,所以使用while循環
            while的結束條件,讀取到null結束
         */
        String line;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }

        //3.釋放資源
        br.close();
    }

綜合練習

package com.itheima.demo01.BufferedStream;

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

/*
    練習:
        對文本的內容進行排序
        按照(1,2,3....)順序排序
    分析:
        1.創建一個HashMap集合對象,可以:存儲每行文本的序號(1,2,3,..);value:存儲每行的文本
        2.創建字符緩衝輸入流對象,構造方法中綁定字符輸入流
        3.創建字符緩衝輸出流對象,構造方法中綁定字符輸出流
        4.使用字符緩衝輸入流中的方法readline,逐行讀取文本
        5.對讀取到的文本進行切割,獲取行中的序號和文本內容
        6.把切割好的序號和文本的內容存儲到HashMap集合中(key序號是有序的,會自動排序1,2,3,4..)
        7.遍歷HashMap集合,獲取每一個鍵值對
        8.把每一個鍵值對,拼接爲一個文本行
        9.把拼接好的文本,使用字符緩衝輸出流中的方法write,寫入到文件中
        10.釋放資源
 */
public class Demo05Test {
    public static void main(String[] args) throws IOException {
        //1.創建一個HashMap集合對象,可以:存儲每行文本的序號(1,2,3,..);value:存儲每行的文本
        HashMap<String,String> map = new HashMap<>();
        //2.創建字符緩衝輸入流對象,構造方法中綁定字符輸入流
        BufferedReader br = new BufferedReader(new FileReader("10_IO\\in.txt"));
        //3.創建字符緩衝輸出流對象,構造方法中綁定字符輸出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("10_IO\\out.txt"));
        //4.使用字符緩衝輸入流中的方法readline,逐行讀取文本
        String line;
        while((line = br.readLine())!=null){
            //5.對讀取到的文本進行切割,獲取行中的序號和文本內容
            String[] arr = line.split("\\.");
            //6.把切割好的序號和文本的內容存儲到HashMap集合中(key序號是有序的,會自動排序1,2,3,4..)
            map.put(arr[0],arr[1]);
        }

        //7.遍歷HashMap集合,獲取每一個鍵值對
        for(String key : map.keySet()){
            String value = map.get(key);
            //8.把每一個鍵值對,拼接爲一個文本行
            line = key + "." + value;
            //9.把拼接好的文本,使用字符緩衝輸出流中的方法write,寫入到文件中
            bw.write(line);
            bw.newLine();//寫換行
        }
        //10.釋放資源
        bw.close();
        br.close();
    }
}

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章