Java IO之包裝流詳解

根據功能分為節點流和包裝流(處理流)

節點流:可以從或向一個特定的地方(節點)讀寫數據。如FileReader.

處理流:是對一個已存在的流的連接和封裝,通過所封裝的流的功能調用實現數據讀寫。如BufferedReader.處理流的構造方法總是要帶一個其他的流對象做參數。一個流對象經過其他流的多次包裝,稱為流的鏈接。

1、前面講的字符輸入輸出流,字節輸入輸出流都是字節流。那麼什麼是包裝流呢?

①、包裝流隱藏瞭底層節點流的差異,並對外提供瞭更方便的輸入\輸出功能,讓我們隻關心這個高級流的操作

②、使用包裝流包裝瞭節點流,程序直接操作包裝流,而底層還是節點流和IO設備操作

③、關閉包裝流的時候,隻需要關閉包裝流即可

2、緩沖流  

緩沖流:是一個包裝流,目的是緩存作用,加快讀取和寫入數據的速度。

字節緩沖流BufferedInputStreamBufferedOutputStream

字符緩沖流BufferedReaderBufferedWriter

案情回放:我們在將字符輸入輸出流、字節輸入輸出流的時候,讀取操作,通常都會定義一個字節或字符數組,將讀取/寫入的數據先存放到這個數組裡面,然後在取數組裡面的數據。這比我們一個一個的讀取/寫入數據要快很多,而這也就是緩沖流的由來。隻不過緩沖流裡面定義瞭一個 數組用來存儲我們讀取/寫入的數據,當內部定義的數組滿瞭(註意:我們操作的時候外部還是會定義一個小的數組,小數組放入到內部數組中),就會進行下一步操作。       

下面是沒有用緩沖流的操作:   

//1、創建目標對象,輸入流表示那個文件的數據保存到程序中。不寫盤符,默認該文件是在該項目的根目錄下
            //a.txt 保存的文件內容為:AAaBCDEF
        File target = new File("io"+File.separator+"a.txt");
        //2、創建輸入流對象
        InputStream in = new FileInputStream(target);
        //3、具體的 IO 操作(讀取 a.txt 文件中的數據到程序中)
            /**
             * 註意:讀取文件中的數據,讀到最後沒有數據時,返回-1
             *  int read():讀取一個字節,返回讀取的字節
             *  int read(byte[] b):讀取多個字節,並保存到數組 b 中,從數組 b 的索引為 0 的位置開始存儲,返回讀取瞭幾個字節
             *  int read(byte[] b,int off,int len):讀取多個字節,並存儲到數組 b 中,從數組b 的索引為 0 的位置開始,長度為len個字節
             */
        //int read():讀取一個字節,返回讀取的字節
        int data1 = in.read();//獲取 a.txt 文件中的數據的第一個字節
        System.out.println((char)data1); //A
        //int read(byte[] b):讀取多個字節保存到數組b 中
        byte[] buffer  = new byte[10];//這裡我們定義瞭一個 長度為 10 的字節數組,用來存儲讀取的數據
        in.read(buffer);//獲取 a.txt 文件中的前10 個字節,並存儲到 buffer 數組中
        System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 67, 68, 69, 70, 0, 0, 0]
        System.out.println(new String(buffer)); //AaBCDEF[][][]
        //int read(byte[] b,int off,int len):讀取多個字節,並存儲到數組 b 中,從索引 off 開始到 len
        in.read(buffer, 0, 3);
        System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 0, 0, 0, 0, 0, 0, 0]
        System.out.println(new String(buffer)); //AaB[][][][][][][]
        //4、關閉流資源
        in.close();

我們查看 緩沖流的 JDK 底層源碼,可以看到,程序中定義瞭這樣的 緩存數組,大小為 8192

BufferedInputStream:

BufferedOutputStream:

//字節緩沖輸入流
        BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream("io"+File.separator+"a.txt"));
        //定義一個字節數組,用來存儲數據
        byte[] buffer = new byte[1024];
        int len = -1;//定義一個整數,表示讀取的字節數
        while((len=bis.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
        //關閉流資源
        bis.close();<br data-filtered="filtered"><br data-filtered="filtered">
        //字節緩沖輸出流
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("io"+File.separator+"a.txt"));
        bos.write("ABCD".getBytes());
        bos.close();
//字符緩沖輸入流
        BufferedReader br = new BufferedReader(
                new FileReader("io"+File.separator+"a.txt"));
        char[] buffer = new char[10];
        int len = -1;
        while((len=br.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
        br.close();
        //字符緩沖輸出流
        BufferedWriter bw = new BufferedWriter(
                new FileWriter("io"+File.separator+"a.txt"));
        bw.write("ABCD");
        bw.close();

3、轉換流:把字節流轉換為字符流

InputStreamReader:把字節輸入流轉換為字符輸入流

OutputStreamWriter:把字節輸出流轉換為字符輸出流

用轉換流進行文件的復制:

/**
         * 將 a.txt 文件 復制到 b.txt 中
         */
        //1、創建源和目標
        File srcFile = new File("io"+File.separator+"a.txt");
        File descFile = new File("io"+File.separator+"b.txt");
        //2、創建字節輸入輸出流對象
        InputStream in = new FileInputStream(srcFile);
        OutputStream out = new FileOutputStream(descFile);
        //3、創建轉換輸入輸出對象
        Reader rd = new InputStreamReader(in);
        Writer wt = new OutputStreamWriter(out);
        //3、讀取和寫入操作
        char[] buffer = new char[10];//創建一個容量為 10 的字符數組,存儲已經讀取的數據
        int len = -1;//表示已經讀取瞭多少個字符,如果是 -1,表示已經讀取到文件的末尾
        while((len=rd.read(buffer))!=-1){
            wt.write(buffer, 0, len);
        }
        //4、關閉流資源
        rd.close();
        wt.close();

4、內存流(數組流):

把數據先臨時存在數組中,也就是內存中。所以關閉 內存流是無效的,關閉後還是可以調用這個類的方法。底層源碼的 close()是一個空方法

①、字節內存流:ByteArrayOutputStreamByteArrayInputStream

//字節數組輸出流:程序---》內存
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        //將數據寫入到內存中
        bos.write("ABCD".getBytes());
        //創建一個新分配的字節數組。 其大小是此輸出流的當前大小,緩沖區的有效內容已被復制到其中。
        byte[] temp = bos.toByteArray();
        System.out.println(new String(temp,0,temp.length));
        byte[] buffer = new byte[10];
        ///字節數組輸入流:內存---》程序
        ByteArrayInputStream bis = new ByteArrayInputStream(temp);
        int len = -1;
        while((len=bis.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
        //這裡不寫也沒事,因為源碼中的 close()是一個空的方法體
        bos.close();
        bis.close();

②、字符內存流:CharArrayReaderCharArrayWriter

//字符數組輸出流
        CharArrayWriter caw = new CharArrayWriter();
        caw.write("ABCD");
        //返回內存數據的副本
        char[] temp = caw.toCharArray();
        System.out.println(new String(temp));
        //字符數組輸入流
        CharArrayReader car = new CharArrayReader(temp);
        char[] buffer = new char[10];
        int len = -1;
        while((len=car.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }

③、字符串流:StringReader,StringWriter(把數據臨時存儲到字符串中)

//字符串輸出流,底層采用 StringBuffer 進行拼接
        StringWriter sw = new StringWriter();
        sw.write("ABCD");
        sw.write("帥鍋");
        System.out.println(sw.toString());//ABCD帥鍋
        //字符串輸入流
        StringReader sr = new StringReader(sw.toString());
        char[] buffer = new char[10];
        int len = -1;
        while((len=sr.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));//ABCD帥鍋
        }

5、合並流:把多個輸入流合並為一個流,也叫順序流,因為在讀取的時候是先讀第一個,讀完瞭在讀下面一個流。

//定義字節輸入合並流
        SequenceInputStream seinput = new SequenceInputStream(
                new FileInputStream("io/a.txt"), new FileInputStream("io/b.txt"));
        byte[] buffer = new byte[10];
        int len = -1;
        while((len=seinput.read(buffer))!=-1){
            System.out.println(new String(buffer,0,len));
        }
        seinput.close();

總結

本篇文章就到這裡瞭,希望能夠給你帶來幫助,也希望您能夠多多關註WalkonNet的更多內容!

推薦閱讀: