今日內容介紹

轉換流
緩衝流

1 轉換流

在學習字符流(FileReader、FileWriter)的時候，其中說如果需要指定編碼和緩衝區大小時，可以在字節流的基礎上，構造一個InputStreamReader或者OutputStreamWriter，這又是什麼意思呢？

OutputStreamWriter類

查閱OutputStreamWriter的API介紹，OutputStreamWriter 是字符流通向字節流的橋樑：可使用指定的字符編碼表，將要寫入流中的字符編碼成字節。它的作用的就是，將字符串按照指定的編碼表轉成字節，在使用字節流將這些字節寫出去。

代碼演示：

public static void writeCN() throws Exception {

        //創建與文件關聯的字節輸出流對象

        FileOutputStream fos = new FileOutputStream("c:\\cn8.txt");

        //創建可以把字符轉成字節的轉換流對象，並指定編碼

        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");

        //調用轉換流，把文字寫出去，其實是寫到轉換流的緩衝區中

        osw.write("你好");//寫入緩衝區。

        osw.close();

    }

View Code

OutputStreamWriter流對象，它到底如何把字符轉成字節輸出的呢？

其實在OutputStreamWriter流中維護自己的緩衝區，當我們調用OutputStreamWriter對象的write方法時，會拿着字符到指定的碼錶中進行查詢，把查到的字符編碼值轉成字節數存放到OutputStreamWriter緩衝區中。然後再調用刷新功能，或者關閉流，或者緩衝區存滿後會把緩衝區中的字節數據使用字節流寫到指定的文件中。

InputStreamReader類

查閱InputStreamReader的API介紹，InputStreamReader 是字節流通向字符流的橋樑：它使用指定的字符編碼表讀取字節並將其解碼爲字符。它使用的字符集可以由名稱指定或顯式給定，或者可以接受平臺默認的字符集。

代碼演示

public class InputStreamReaderDemo {

    public static void main(String[] args) throws IOException {

        //演示字節轉字符流的轉換流

        readCN();

    }

    public static void readCN() throws IOException{

        //創建讀取文件的字節流對象

        InputStream in = new FileInputStream("c:\\cn8.txt");

        //創建轉換流對象

        //InputStreamReader isr = new InputStreamReader(in);這樣創建對象，會用本地默認碼錶讀取，將會發生錯誤解碼的錯誤

InputStreamReader isr = new InputStreamReader(in,"utf-8");

        //使用轉換流去讀字節流中的字節

        int ch = 0;

        while((ch = isr.read())!=-1){

            System.out.println((char)ch);

        }

        //關閉流

        isr.close();

    }

}

View Code

注意：在讀取指定的編碼的文件時，一定要指定編碼格式，否則就會發生解碼錯誤，而發生亂碼現象。

轉換流和子類區別

發現有如下繼承關係：

OutputStreamWriter:

|--FileWriter:

InputStreamReader:

|--FileReader;

父類和子類的功能有什麼區別呢？

OutputStreamWriter和InputStreamReader是字符和字節的橋樑：也可以稱之爲字符轉換流。字符轉換流原理：字節流+編碼表。

FileWriter和FileReader：作爲子類，僅作爲操作字符文件的便捷類存在。當操作的字符文件，使用的是默認編碼表時可以不用父類，而直接用子類就完成操作了，簡化了代碼。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默認字符集。

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。

FileReader fr = new FileReader("a.txt");

這三句代碼的功能是一樣的，其中第三句最爲便捷。

注意：一旦要指定其他編碼時，絕對不能用子類，必須使用字符轉換流。什麼時候用子類呢？

條件：

1、操作的是文件。2、使用默認編碼。

總結：

字節--->字符：看不懂的--->看的懂的。需要讀。輸入流。 InputStreamReader

字符--->字節：看的懂的--->看不懂的。需要寫。輸出流。 OutputStreamWriter

2 緩衝流

在我們學習字節流與字符流的時候，大家都進行過讀取文件中數據的操作，讀取數據量大的文件時，讀取的速度會很慢，很影響我們程序的效率，那麼，我想提高速度，怎麼辦？

Java中提高了一套緩衝流，它的存在，可提高IO流的讀寫速度

緩衝流，根據流的分類分類字節緩衝流與字符緩衝流。

字節緩衝流

字節緩衝流根據流的方向，共有2個

寫入數據到流中，字節緩衝輸出流 BufferedOutputStream
讀取流中的數據，字節緩衝輸入流 BufferedInputStream

它們的內部都包含了一個緩衝區，通過緩衝區讀寫，就可以提高了IO流的讀寫速度

字節緩衝輸出流BufferedOutputStream

通過字節緩衝流，進行文件的讀寫操作寫數據到文件的操作

構造方法

public BufferedOutputStream(OutputStream out)創建一個新的緩衝輸出流，以將數據寫入指定的底層輸出流。

public class BufferedOutputStreamDemo01 {

    public static void main(String[] args) throws IOException {

          

        //寫數據到文件的方法

        write();

    }

 

    /*

     * 寫數據到文件的方法

     * 1,創建流

     * 2，寫數據

     * 3，關閉流

     */

    private static void write() throws IOException {

        //創建基本的字節輸出流

        FileOutputStream fileOut = new FileOutputStream("abc.txt");

        //使用高效的流，把基本的流進行封裝，實現速度的提升

        BufferedOutputStream out = new BufferedOutputStream(fileOut);

        //2，寫數據

        out.write("hello".getBytes());

        //3，關閉流

        out.close();

    }

}

View Code

字節緩衝輸入流 BufferedInputStream

剛剛我們學習了輸出流實現了向文件中寫數據的操作，那麼，現在我們完成讀取文件中數據的操作

構造方法

public BufferedInputStream(InputStream in)

 /*

     * 從文件中讀取數據

     * 1,創建緩衝流對象

     * 2，讀數據，打印

     * 3，關閉

     */

    private static void read() throws IOException {

        //1,創建緩衝流對象

        FileInputStream fileIn = new FileInputStream("abc.txt");

        //把基本的流包裝成高效的流

        BufferedInputStream in = new BufferedInputStream(fileIn);

        //2，讀數據

        int ch = -1;

        while ( (ch = in.read()) != -1 ) {

            //打印

            System.out.print((char)ch);

        }

        //3，關閉

        in.close();

    }

View Code

使用基本的流與高效的流完成複製文件

我們一直在說，高效的流速度快並高效，怎麼體現呢？需要通過一個複製文件耗時的比較過程，來體驗一下高效流帶來的快感。

/*

* 需求：將d:\\test.avi文件進行復制

*         採用4種方式複製

*         方式1：採用基本的流，一次一個字節的方式複製    共耗時 224613毫秒

*         方式2：採用基本的流，一個多個字節的方式賦值    共耗時 327毫秒

*         方式3：採用高效的流，一次一個字節的方式複製    共耗時 2047毫秒

*         方式4：採用高效的流，一個多個字節的方式賦值    共耗時 96毫秒

*

* 數據源： d:\\test.avi

* 目的地1: d:\\copy1.avi

* 目的地2: d:\\copy2.avi

* 目的地3: d:\\copy3.avi

* 目的地4: d:\\copy4.avi

*

* 實現的步驟：

*     1，指定數據源

*     2，指定目的地

*     3，讀數據

*     4，寫數據

*     5，關閉流

*

*/

public class CopyAVI {

    public static void main(String[] args) throws IOException {

        //開始計時

        long start = System.currentTimeMillis();

        //方式1：採用基本的流，一次一個字節的方式複製

        //method1("d:\\test.avi", "d:\\copy1.avi");

        //方式2：採用基本的流，一個多個字節的方式賦值

        //method2("d:\\test.avi", "d:\\copy2.avi");

        //方式3：採用高效的流，一次一個字節的方式複製

        //method3("d:\\test.avi", "d:\\copy3.avi");

        //方式4：採用高效的流，一個多個字節的方式賦值

        method4("d:\\test.avi", "d:\\copy4.avi");

          

        //結束計時

        long end = System.currentTimeMillis();

        //打印耗時多少毫秒

        System.out.println("共耗時 " +(end - start)+ "毫秒");

    }

    

    //方式4：採用高效的流，一個多個字節的方式賦值

    private static void method4(String src, String dest) throws IOException {

        //1，指定數據源

        BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));

         //2，指定目的地

        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));

         //3，讀數據

        byte[] buffer = new byte[1024];

        int len = -1;

        while ( (len = in.read(buffer)) != -1) {

            //4,寫數據

            out.write(buffer, 0, len);

        }

         //5，關閉流

        in.close();

        out.close();

    }

 

    //方式3：採用高效的流，一次一個字節的方式複製

    private static void method3(String src, String dest) throws IOException {

        //1，指定數據源

        BufferedInputStream in = new BufferedInputStream(new FileInputStream(src));

         //2，指定目的地

        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest));

         //3，讀數據

        int ch = -1;

        while ((ch=in.read()) != -1) {

            //4，寫數據

            out.write(ch);    

        }        

         //5，關閉流

        in.close();

        out.close();

    }

 

    //方式2：採用基本的流，一個多個字節的方式賦值

    private static void method2(String src, String dest) throws IOException {

        //1，指定數據源

        FileInputStream in = new FileInputStream(src);

        //2，指定目的地

        FileOutputStream out = new FileOutputStream(dest);

        //3，讀數據

        byte[] buffer = new byte[1024];

        int len = -1;

        while ( (len=in.read(buffer)) != -1) {

            //4，寫數據

            out.write(buffer, 0, len);

        }

        //5，關閉流

        in.close();

        out.close();

    }

 

    //方式1：採用基本的流，一次一個字節的方式複製

    private static void method1(String src, String dest) throws IOException {

        //1，指定數據源

        FileInputStream in = new FileInputStream(src);

        //2，指定目的地

        FileOutputStream out = new FileOutputStream(dest);

        //3，讀數據

        int ch = -1;

        while (( ch=in.read()) != -1) {

            //4，寫數據

            out.write(ch);

        }

        //5，關閉流

        in.close();

        out.close();

    }

}

View Code

字符緩衝流

字符緩衝輸入流 BufferedReader
字符緩衝輸出流 BufferedWriter

完成文本數據的高效的寫入與讀取的操作

字符緩衝輸出流 BufferedWriter

將文本寫入字符輸出流，緩衝各個字符，從而提供單個字符、數組和字符串的高效寫入。

方法：

　　　　　　　　void newLine() 根據當前的系統，寫入一個換行符

/*

* BufferedWriter 字符緩衝輸出流

* 方法

*     public void newLine()寫入一個行分隔符

*

* 需求：通過緩衝輸出流寫入數據到文件

* 分析：

*     1，創建流對象

*     2，寫數據

*     3，關閉流

*

*/

public class BufferedWriterDemo {

    public static void main(String[] args) throws IOException {

        //創建流

        //基本字符輸出流

        FileWriter fileOut = new FileWriter("file.txt");

        //把基本的流進行包裝

        BufferedWriter out = new BufferedWriter(fileOut);

        //2，寫數據

        for (int i=0; i<5; i++) {

            out.write("hello");

            out.newLine();

        }

        //3,關閉流

        out.close();

    }

}

View Code

字符緩衝輸入流 BufferedReader

從字符輸入流中讀取文本，緩衝各個字符，從而實現字符、數組和行的高效讀取。

方法

　　　　　　　　public String readLine() 讀取一個文本行，包含該行內容的字符串，不包含任何行終止符，如果已到達流末尾，則返回 null

/*

* BufferedReader 字符緩衝輸入流

*

* 方法：

*     String readLine()

* 需求：從文件中讀取數據，並顯示數據

*/

public class BufferedReaderDemo {

    public static void main(String[] args) throws IOException {

        //1,創建流

        BufferedReader in = new BufferedReader(new FileReader("file.txt"));

        //2，讀數據

        //一次一個字符

        //一次一個字符數組

        //一次讀取文本中一行的字符串內容

        String line = null;

        while( (line = in.readLine()) != null ){

            System.out.println(line);

        }

          

        //3,關閉流

        in.close();

    }

}

View Code

使用字符緩衝流完成文本文件的複製

剛剛我們學習完了緩衝流，現在我們就使用字符緩衝流的特有功能，完成文本文件的複製

/*

* 採用高效的字符緩衝流，完成文本文件的賦值

*

* 數據源： file.txt

* 目的地： copyFile.txt

*

* 分析：

*     1，指定數據源，是數據源中讀數據，採用輸入流

*     2,指定目的地，是把數據寫入目的地，採用輸出流

*     3,讀數據

*     4，寫數據

*     5，關閉流

*/

public class CopyTextFile {

    public static void main(String[] args) throws IOException {

        //1，指定數據源，是數據源中讀數據，採用輸入流

        BufferedReader in = new BufferedReader(new FileReader("file.txt"));

        //2,指定目的地，是把數據寫入目的地，採用輸出流

        BufferedWriter out = new BufferedWriter(new FileWriter("copyFile.txt"));

        //3,讀數據

        String line = null;

        while ( (line = in.readLine()) != null ) {

            //4，寫數據

            out.write(line);

            //寫入換行符號

            out.newLine();

        }

        //5，關閉流

        out.close();

        in.close();

    }

}

View Code

流的操作規律

IO流中對象很多，解決問題(處理設備上的數據時)到底該用哪個對象呢？　　

把IO流進行了規律的總結(四個明確)：

明確一：要操作的數據是數據源還是數據目的。

源：InputStream Reader

目的：OutputStream Writer

先根據需求明確要讀，還是要寫。

明確二：要操作的數據是字節還是文本呢？

源：

字節：InputStream

文本：Reader

目的：

字節：OutputStream

文本：Writer

已經明確到了具體的體系上。

明確三：明確數據所在的具體設備。

源設備：

硬盤：文件 File開頭。

內存：數組，字符串。

鍵盤：System.in;

網絡：Socket

目的設備：

硬盤：文件 File開頭。

內存：數組，字符串。

屏幕：System.out

網絡：Socket

完全可以明確具體要使用哪個流對象。

明確四：是否需要額外功能呢？

額外功能：

轉換嗎？轉換流。InputStreamReader OutputStreamWriter

高效嗎？緩衝區對象。BufferedXXX

InputStream

FileInputStream

BufferedInputStream

OuputStream

FileOutputStream

BufferedOuputStream

Writer

OutputStreamWriter

FileWriter

BufferedWriter

Reader

InputStreamReader

FileReader

BufferedReader

3 總結

知識點總結

字節流
- 字節輸入流 InputStream
  - FileInputStream 操作文件的字節輸入流
  - BufferedInputStream高效的字節輸入流
- 字節輸出流 OutputStream
  - FileOutputStream 操作文件的字節輸出流
  - BufferedOutputStream 高效的字節輸出流
字符流
- 字符輸入流 Reader
  - FileReader 操作文件的字符輸入流
  - BufferedReader 高效的字符輸入流
  - InputStreamReader 輸入操作的轉換流(把字節流封裝成字符流)
- 字符輸出流 Writer
  - FileWriter 操作文件的字符輸出流
  - BufferedWriter 高效的字符輸出流
  - OutputStreamWriter 輸出操作的轉換流(把字節流封裝成字符流)
方法：
- 讀數據方法：
  - read() 一次讀一個字節或字符的方法
  - read(byte[] char[]) 一次讀一個數組數據的方法
  - readLine() 一次讀一行字符串的方法(BufferedReader類特有方法)
  - readObject() 從流中讀取對象(ObjectInputStream特有方法)
- 寫數據方法：
  - write(int) 一次寫一個字節或字符到文件中
  - write(byte[] char[]) 一次寫一個數組數據到文件中
  - write(String) 一次寫一個字符串內容到文件中
  - writeObject(Object ) 寫對象到流中(ObjectOutputStream類特有方法)
  - newLine() 寫一個換行符號(BufferedWriter類特有方法)

向文件中寫入數據的過程

1，創建輸出流對象

2，寫數據到文件

3，關閉輸出流
從文件中讀數據的過程

創建輸入流對象
從文件中讀數據
關閉輸入流

文件複製的過程

創建輸入流（數據源）
創建輸出流（目的地）
從輸入流中讀數據
通過輸出流，把數據寫入目的地
關閉流

Java_轉換流和緩衝流

1 轉換流

OutputStreamWriter類

InputStreamReader類

轉換流和子類區別

2 緩衝流

字節緩衝流

字節緩衝輸出流BufferedOutputStream

字節緩衝輸入流 BufferedInputStream

使用基本的流與高效的流完成複製文件

字符緩衝流

字符緩衝輸出流 BufferedWriter

字符緩衝輸入流 BufferedReader

使用字符緩衝流完成文本文件的複製

流的操作規律

3 總結

知識點總結

Vue 響應式原理模擬以及最小版本的 Vue的模擬

gulp涉及的自動化構建的插件gulp-load-plugins,gulp-sass,gulp-imagemin等以及啓動服務browser-sync相關操作

模擬Promise的功能

JS的函數式編程範式

學習apply()方法的使用,記錄一下

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結