一、概念及分類

? ? ? ?InputStream(輸入流)/OutputStream(輸出流)是所有字節(jié)輸入輸出流的父類

【注】輸入流和輸出流的是按程序運(yùn)行所在的內(nèi)存的角度劃分的

? ? ? ? ? 字節(jié)流操作的數(shù)據(jù)單元是8的字節(jié)，字符流操作的數(shù)據(jù)單元是16位的字符

【流的概念】

——————————

ooooooooooooooooo

—————————— (輸入流模型，文件從頭(左邊)到尾(右邊)，)

↑,(記錄指針)

?

每個(gè)‘’o“”看出一個(gè)"水滴"，不管是字節(jié)流還是字符流，每個(gè)水滴是最小的輸入/輸出單位，對于字節(jié)流而言，每個(gè)水滴是1個(gè)字節(jié)(8位)

對于字符流而言，每個(gè)水滴是1個(gè)字符(16位)。輸入流使用隱含的記錄指針來表示當(dāng)前正準(zhǔn)備從哪個(gè)水滴開始讀取，每當(dāng)程序從InputStream或

Reader里取出一個(gè)或多個(gè)水滴后，指針自動(dòng)向后(指針從左往右)移動(dòng)。此外，還可以控制記錄指針的移動(dòng)，比如說設(shè)置偏移量off。

對于輸出流相對于把水滴放入輸入流水管中，也有記錄指針自動(dòng)控制移動(dòng)，每當(dāng)程序向OutputStream或Writer輸出一個(gè)或多個(gè)水滴后，記錄指針自

動(dòng)向后移動(dòng)。

?

1、InputStream(重要的是 文件操作字節(jié)流FileInputStream子類和帶8KB緩沖數(shù)組的ButteredInputStream)

? ? ??此抽象類是表示字節(jié)輸入流的所有類的父類。InputSteam是一個(gè)抽象類，它不可以實(shí)例化。 數(shù)據(jù)的讀取需要由它的子類來實(shí)現(xiàn)。根據(jù)節(jié)點(diǎn)的不同，

它派生了不同的節(jié)點(diǎn)流子類 。?繼承自InputSteam的流都是用于向程序中輸入數(shù)據(jù)，且數(shù)據(jù)的單位為字節(jié)(8 bit)。

? ? ??int read()：從(所寫程序的源文件中)一個(gè)一個(gè)字節(jié)讀取數(shù)據(jù)，并將字節(jié)的值作為int類型返回(0-255之間的一個(gè)值)。

? ? ? ? ? ? ? ? ? ? ? ? ?如果未讀出字節(jié)則返回-1(返回值為-1表示讀取結(jié)束)。

? ? ? int (byte b[]) :一段一段的讀取數(shù)據(jù)

? ? ??void close()： (通知操作系統(tǒng))關(guān)閉輸入流對象，釋放相關(guān)系統(tǒng)資源。

【代碼示例】字節(jié)文件操作流_不帶緩沖數(shù)組 （FileInputStream）

  1 /*輸入流(從數(shù)據(jù)源輸入到程序中) :數(shù)據(jù)源-->>程序，是從數(shù)據(jù)源(源文件、類比書本上知識)讀取(read)數(shù)據(jù)到程序(目標(biāo)程序、大腦)
  2  * 輸入流對應(yīng)read()方法 ，從書本上流入(輸入、Input)到大腦中，而大腦需要讀取(read)書本上的知識  
  3 * 步驟：選擇源數(shù)據(jù)-->>選擇流(選哪個(gè)搬家公司)-->>操作(一個(gè)一個(gè)讀/寫or一段一段讀/寫,即怎么搬家)-->>釋放系統(tǒng)資源(讓搬家公司走)
  4  *  
  5   一、 read():從輸入流中讀取一個(gè)8位的字節(jié)的數(shù)據(jù),(程序自動(dòng))把它轉(zhuǎn)成0-255之間的整數(shù),并返回這個(gè)整數(shù)。 采用逐個(gè)讀取字節(jié)
  6 1.從讀取流讀取的是一個(gè)一個(gè)字節(jié) 
  7 2.返回的是字節(jié)的(0-255)內(nèi)的字節(jié)值 ASCII碼
  8 3.讀一個(gè)下次就自動(dòng)到下一個(gè),如果碰到-1說明沒有值了.
  9 
 10  二、 read(byte[] bytes)： 從輸入流中最多讀取bytes.length(定量)個(gè)字節(jié)的數(shù)據(jù)(最后一次可能不滿，前面肯定是滿的)，并將
 11  它們存在byte數(shù)組中，返回實(shí)際讀取的字節(jié)數(shù)
 12 1.從讀取流讀取一定數(shù)量的字節(jié),如果比如文件總共是102個(gè)字節(jié)
 13 2.我們定義的數(shù)組長度是10,那么默認(rèn)前面10次都是讀取10個(gè)長度
 14 3.最后一次不夠十個(gè),那么讀取的是2個(gè)
 15 4.這十一次,每次都是放入10個(gè)長度的數(shù)組.
 16 
 17  三、read(byte[] bytes,int off ,int len)：從輸入流中最多讀取len個(gè)字節(jié)(字節(jié)可以設(shè)定，但不超過數(shù)組最大容量)將其存在bytes
 18 數(shù)組中，但放入數(shù)組的時(shí)候并不是從起點(diǎn)開始的是從可以自己設(shè)定的off位置開始的(當(dāng)然可以設(shè)為0，表示從起點(diǎn)開始)返回實(shí)際讀取的字節(jié)數(shù)
 19 1.從讀取流讀取一定數(shù)量的字節(jié),如果比如文件總共是102個(gè)字節(jié)
 20 2.我們定義的數(shù)組長度是10,但是這里我們寫read(bytes,0,9)那么每次往里面添加的(將只會(huì)是9個(gè)長度),就要讀12次,最后一次放入3個(gè).
 21 3.所以一般讀取流都不用這個(gè)而是用上一個(gè)方法:read(byte[]);
 22 
 23   void close()關(guān)閉輸入流并釋放與該流相關(guān)的所有系統(tǒng)資源
 24  */
 25 package cn.sxt.test;
 26 
 27 import java.io.File;
 28 import java.io.FileInputStream;
 29 import java.io.IOException;
 30 import java.io.InputStream;
 31 
 32 
 33 public class Test_0329_InputStream {
 34     public static void main(String[] args) throws IOException { //與外界(操作系統(tǒng)讀寫)有聯(lián)系,可能有異常，所以拋出異常
 35         //1、選擇源文件 內(nèi)容為：hello China I love you
 36         File file=new File("編碼_GBK_純英文.txt");    //GBK編碼 英文占一個(gè)字節(jié)
 37         //2、選擇流 FileInputStream 順序的讀取文件，只要不關(guān)閉每次調(diào)用read()方法就順序的讀取源數(shù)據(jù)中【剩余】的內(nèi)容
 38         InputStream iStream=new FileInputStream(file);
 39         
 40         //這種寫法也對，綜合了第一步和第二步，更加簡單
 41         FileInputStream iStream2=new FileInputStream("編碼_GBK_純英文.txt");
 42         
 43         //3-1-1、有點(diǎn)繞的寫法   測試read()方法選擇操作 (讀/寫) 循環(huán)讀取 一個(gè)一個(gè)字節(jié)去讀
 44         /*int temp;
 45         while ((temp=iStream.read())!=-1) {
 46             System.out.print((char)temp);
 47             
 48         }*/
 49          //3-1-2、最可以讓人理解的一種寫法
 50         /*int b=0;//b的作用記住每次讀取的一個(gè)字節(jié)的整形返回值(英文、數(shù)字及常見符號其實(shí)就是ASCII碼的值)
 51         while (true) {
 52             b=iStream.read();
 53             if (b==-1) {//如果讀出字節(jié)為-1 跳出整個(gè)循環(huán)表示已經(jīng)到文件末尾
 54                 break;
 55             }
 56             System.out.print((char)b);
 57         }*/
 58         
 59         
 60         /*//3-2 測試read(byte[] b)方法 將數(shù)據(jù)讀取到準(zhǔn)備好的字節(jié)數(shù)組(byte[],這里名字叫datas)中，同時(shí)返回讀取字節(jié)數(shù)組的實(shí)際長度
 61         // 如果到結(jié)尾，返回-1
 62         byte datas[]=new byte[4]; //新建一個(gè)大小為4的字節(jié)(byte)數(shù)組，名字叫datas.
 63         int length=iStream.read(datas);//length=4 就是每次讀取時(shí)字符的實(shí)際長度，因?yàn)樽x到最后是可能剩余的字符不足4 可能為3
 64                                  //當(dāng)最后讀取完后，再去讀取時(shí)發(fā)現(xiàn)沒有了，則返回-1 表示讀取結(jié)束
 65          //String msg2=new String(datas, 0, datas.length, "GBK"); 標(biāo)準(zhǔn)解碼語句
 66         String msg2=new String(datas, 0, length); //字節(jié)數(shù)組解碼成字符 
 67         System.out.println(msg2); //輸出 "hell" 因?yàn)闆]用循環(huán)只表示一次讀取的情況,一次只讀取了4個(gè)字節(jié)的字符
 68         //可以加循環(huán)或者加大datas數(shù)組的大小，讓其一次讀完 
 69         */
 70          
 71         
 72         
 73         //3-3 測試read(byte[] b,int off,int len)方法 。讀取任意一段字節(jié)。off(偏移量):表示把源文件中從頭(即下標(biāo))開始讀取到的字節(jié)數(shù)存在
 74         //datas數(shù)組下標(biāo)為off開始的位置，讀取源文件的長度為len,也就是在datas數(shù)組中下標(biāo)為off開始位置存儲(chǔ)長度為len字節(jié)的源數(shù)據(jù) 
 75         byte datas[]=new byte[7];
 76         
 77         //雖然定義的數(shù)組datas大小為7個(gè)字節(jié)，但每次只添加4個(gè)字節(jié)的字符,表示使用datas數(shù)組的實(shí)際使用空間為4個(gè)字節(jié)。
 78         //2的含義：表示把讀取到數(shù)據(jù)存在datas數(shù)組下標(biāo)為2的位置 即datas[2]='h'意味著datas[0]=datas[1]=0，即null空字符
 79         //4的含義：在datas數(shù)組中從下標(biāo)為2的位置開始存儲(chǔ)一段長度為4的源數(shù)據(jù)字節(jié)(從源文件開頭讀的) 即
 80         //datas[2]=104,'h';datas[3]=101,'e';datas[4]=108,'l';datas[5]=108,'l' datas[6]=0 ,null
 81         int length=iStream.read(datas, 2, 4);//read()方法返回length=4 4：代表實(shí)際存儲(chǔ)一段長度為4的字節(jié)，其它下標(biāo)位置存儲(chǔ)為空
 82         System.out.println(length);
 83         for (int i=0;i<datas.length ;i++) {
 84             System.out.printf("datas[%d]=%d;",i,datas[i]);
 85             
 86         }
 87         
 88         
 89         //ASCII碼 (范圍 0-127)null 0;a 97;b 98;c 99;d 100;e 101;f 102; g 103 ;h 104;i 105; g 106;k 107;l 108  
 90         //字節(jié)數(shù)組解碼成字符  從數(shù)組datas下標(biāo)為1的地方開始解碼(只測試純英文的情況，含中文數(shù)字可能報(bào)異常)。
 91         //解碼長度length=4，代表解碼一段長度為4的字節(jié)碼文件 輸出" hel";也可以length-1 解碼一段長度為3的datas數(shù)組文件
 92         //輸出結(jié)果為" he"  
 93         String msg2=new String(datas, 1, length); //String 構(gòu)造方法，字節(jié)-->>字符 
 94         System.out.println("\n"+msg2); 
 95         
 96         
 97         /*
 98         int data1=iStream.read();//讀取第一個(gè)字符 "h" 輸出的是"h"的ASCLL碼104 
 99         int data2=iStream.read();//讀取第二個(gè)字符 "e"
100         int data3=iStream.read();//讀取第三個(gè)字符 "l"
101         System.out.println(data1);//返回的數(shù)據(jù)的ASCII碼需要強(qiáng)制轉(zhuǎn)型 。文件的末尾如果沒有數(shù)據(jù)返回-1
102         System.out.println((char)data2);
103         System.out.println((char)data3);*/
104         
105         //4、釋放資源
106         iStream.close();
107         
108     }
109 
110 }

?

2、 OutputStream??(重要的是 文件操作字節(jié)流FileOutputStream子類和帶8KB緩沖數(shù)組的ButteredOutputStream子類))

? ? ??此抽象類是表示字節(jié)輸出流的所有類的父類。輸出流接收輸出字節(jié)并將這些字節(jié)發(fā)送到某個(gè)目的地。

? ? ??void write(int n)：向目的地(即所寫程序)中寫入一個(gè)字節(jié)。

? ? ? void write(byte b[])：一段一段去寫數(shù)據(jù)

? ? ? void? (byte b[],int off,int len) ：從指定的字節(jié)數(shù)組寫入len字節(jié)，從偏移量off開始輸出到此輸出流

? ? ? void flush() ：刷新此輸出流，并強(qiáng)制任何緩沖的輸出字節(jié)流被寫出。

? ? ??void close()： (通知操作系統(tǒng))關(guān)閉輸出流對象，釋放相關(guān)系統(tǒng)資源。

【代碼示例】

 1 /*
 2 *輸出(Output)流(Stream)。
 3 *通過寫字( write()方法 ),把大腦中的知識(類比程序)輸出(寫出)到(Output)外界的作業(yè)本上(類比源文件，如a.txt文件),去更改作業(yè)本上原有的內(nèi)容
 4 步驟：創(chuàng)建源-->>選擇流-->>操作(寫出內(nèi)容)-->>釋放資源
 5 void write(int n)：     向目的地(即所寫程序)中寫入一個(gè)字節(jié)。逐個(gè)寫入字節(jié)
 6   n應(yīng)是讀取到的源數(shù)據(jù)編碼值。如把"love"寫入目標(biāo)文件， 一個(gè)一個(gè)字節(jié)讀，讀到'l' 此時(shí)這里的n應(yīng)該是'l'的ASCII碼值108,依次往下讀
 7    while(( len=in.read() )!=-1){
 8          out.write(len);
 9    } 這段程序完成文件的復(fù)制,表示讀到的十進(jìn)制編碼值(0-255之間,英文就是ASCII碼),然后把這個(gè)值送到write()方法中,讓其執(zhí)行寫入操作
10     但是效率很低，它是讀一個(gè)字節(jié)取到編碼值后,然后再根據(jù)編碼值去寫入，循環(huán)往復(fù)。一個(gè)字節(jié)一個(gè)字節(jié)讀和寫.好比很多貨物但每次只送一個(gè),
11     循環(huán)往復(fù),盡管車廂很大,只裝一個(gè),浪費(fèi)油。電腦中就是浪費(fèi)內(nèi)存,不停進(jìn)行磁盤讀寫，速度很慢。       
12     
13 void write(byte b[])：一段一段去寫數(shù)據(jù)。把參數(shù)b指定的字節(jié)數(shù)組的【所有字節(jié)】寫入到目標(biāo)文件中去。批量寫入
14    為了提高送貨速度則可以每次把車廂裝滿，減少送貨次數(shù) 車廂就是byte[]數(shù)組 批量送貨,減少磁盤讀寫
15 void  (byte b[],int off,int len) ：將指定的byte數(shù)組【從偏移量off開始的len個(gè)字節(jié)】寫入到目標(biāo)文件。 批量寫入
16 
17 void flush() ：刷新此輸出流，并強(qiáng)制寫出所有緩沖中的字節(jié)
18 void close() : 關(guān)閉輸出流并釋放系統(tǒng)資源
19 
20  * 
21  */
22 package cn.sxt.test;
23 
24 import java.io.File;
25 import java.io.FileOutputStream;
26 import java.io.IOException;
27 import java.io.OutputStream;
28 
29 public class Test_0329_OutputStream {
30     public static void main(String[] args) throws IOException {
31         //1、給出輸出流目的地(給出作業(yè)本)(與read()不同那個(gè)源文件必須存在,才可以被正確讀出,這里可不存在,幫你創(chuàng)建源文件)
32         File file=new File("編碼_GBK_輸出流.txt");
33         //2、創(chuàng)建指向目的地的輸出流。參數(shù)：true：(前提是文件已存在)表示同意在文件末尾追加新字節(jié)數(shù)組， false：表示不同意，即覆蓋目的地文件的內(nèi)容
34         OutputStream oStream=new FileOutputStream(file,true);
35         //3、讓輸出流把字節(jié)數(shù)組寫入目的地
36         String msg="I love you";
37         byte datas[]=msg.getBytes();
38         //ASCII碼 ：范圍是十進(jìn)制的 0-127
39         //byte：整形變量(8位，范圍十進(jìn)制的-128-127) 字符串-->>字節(jié)存在名叫datas的數(shù)組 ：編碼
40         //再次理解getBytes()方法: 此方法所做的工作就是英文字符(按GBK的方式，本電腦eclipse默認(rèn)是GBK)進(jìn)行編碼,然后把它們的
41         //十進(jìn)制編碼存在datas數(shù)組中,GBK中文占3個(gè)字節(jié)，英文占1個(gè)字節(jié).GBK兼容ACSII碼，所以英文字符的編碼就是它們的ACSII碼
42         //而且一個(gè)datas數(shù)組下標(biāo)對應(yīng)一個(gè)字節(jié)，對于英文1個(gè)下標(biāo)存儲(chǔ)1個(gè)字符如：datas[0]=73對應(yīng)英文字符'I' datas[1]=32 對應(yīng)' '(空格)
43         //假設(shè)有中文字符則是datas[n-1][n][n+1]這3個(gè)連續(xù)的空間共同存儲(chǔ)一個(gè)中文字符(占3個(gè)字節(jié))。這3個(gè)空間返回的分別是這個(gè)        
44         //中文字符的編碼的(23-16位,15-8位,7-0位)的十進(jìn)制數(shù)。
45         
46         for (int i=0;i<datas.length ;i++) {
47             System.out.printf("datas[%d]=%d;",i,datas[i]);
48             //3-1:利用循環(huán)向txt文件中一個(gè)一個(gè)字節(jié)寫入
49             //oStream.write(datas[i]);
50             
51         }
52         //3-2 一段一段字節(jié)去寫入
53         //oStream.write(datas);//把datas數(shù)組中的全部字符寫入目的文件
54         
55         //3-3 寫入部分字節(jié)  往目的地的txt文件中寫了datas數(shù)組的部分字節(jié)(從下標(biāo)2(字符'l')開始，長度為8的一段字節(jié))
56         oStream.write(datas, 2, datas.length-2);
57         
58         //4、關(guān)閉輸出流
59         oStream.close();;
60     }
61 
62 }

?

【示例】利用輸入流和輸出流進(jìn)行文件復(fù)制_不帶緩沖數(shù)組 （FileInputStream）

 1 /*
 2  *利用輸入流和輸出流完成文件的復(fù)制
 3  * 輸入流(InputStream)  書本的知識輸入到大腦中，大腦要讀取(read)知識
 4  * 輸出流(OutputStream) 大腦中的知識要寫出(write)到作業(yè)本上
 5  * 1、為了減少對硬盤的讀寫次數(shù)，提高效率，通常設(shè)置緩存數(shù)組。相應(yīng)地，讀取時(shí)使用的方法為：read(byte[] b)
 6  *                                    寫入時(shí)的方法為：write(byte[ ] b, int off, int length)。
 7  */
 8 package cn.sxt.test;
 9 
10 import java.io.File;
11 import java.io.FileInputStream;
12 import java.io.FileOutputStream;
13 import java.io.IOException;
14 import java.io.InputStream;
15 import java.io.OutputStream;
16 
17 public class Test_0330_CopyFile {
18     public static void main(String[] args) throws Exception {
19 
20         //copy("SongYi.jpg", "Song2.jpg"); 圖片也可復(fù)制，但是要注意設(shè)置緩沖數(shù)組的大小
21         copy("src.txt", "src_copy3.txt");
22     }
23 
24 
25     static void copy(String src,String dest) throws IOException{
26         //1、獲取源數(shù)據(jù)
27         File file =new File(src);//源文件 從這里讀取字節(jié)
28         File file2=new File(dest);//目標(biāo)文件 往這里寫入字節(jié)
29 
30         //2、選擇流
31         InputStream iStream=new FileInputStream(file);//輸入流 。從源文件(書本)輸入到程序中(大腦中)
32         OutputStream oStream=new FileOutputStream(file2);//輸出流。 從程序中(大腦中)輸出到目標(biāo)文件(作業(yè)本)上.采用的是覆蓋,而不是追加
33 
34         //3、選擇操作
35         /*把讀到數(shù)據(jù)存在butter數(shù)組從下標(biāo)0開始的位置，每次存儲(chǔ)長度為數(shù)組的長度(也即一次就讀完)。若butter.length 改為4表示
36          *每次只讀取源文件的(從頭開始的)前4個(gè)字節(jié),存在butter[0]--butter[3]中,至于源文件剩下的需要再次運(yùn)行程序讀取或加個(gè)循環(huán)
37          *對于較大的文件(如圖片)可以加大緩沖數(shù)組的容量
38          */        
39         byte butter[]=new byte[1024];//緩沖數(shù)組，數(shù)組的大小為1024 。中轉(zhuǎn)站 大腦
40         
41         /*  //3-1：整體讀取寫入，每次都固定讀取1024個(gè)字節(jié)
42         iStream.read(butter);
43         oStream.write(butter);*/
44         
45         // 3-2 :可以選擇整體讀取或者部分讀入(即把butter.length的數(shù)值改低).這里起到效果是整體讀取與3-1是一個(gè)道理 
46         iStream.read(butter,0,butter.length);
47         oStream.write(butter, 0, butter.length); 
48         
49         
50         /*//可以具體看看讀取到的內(nèi)容 詳細(xì)步驟
51         iStream.read(butter,0,butter.length);
52         String msg=new String(butter,0,butter.length);//字節(jié)-->>字符串：解碼
53         System.out.println(msg);
54         byte datas[]=msg.getBytes();//對讀取到的msg字符串進(jìn)行編碼:字符串-->>字節(jié)
55         oStream.write(datas, 0, datas.length);  */
56          
57 
58         //4、關(guān)閉流
59         oStream.close();
60         iStream.close();
61 
62     }
63 }

?【代碼示例】字節(jié)文件操作流_帶緩沖數(shù)組 （ButteredInputStream）大小為8192B(大小就是8KB，2^13次方，1KB=1024B，)

·

 1 /** 
 2  * 學(xué)習(xí) BufferedInputStream/BufferedOutputStream 緩沖字節(jié)流類
 3  *復(fù)制文件  測試Java自帶的在緩沖數(shù)組的輸入輸出流
 4  */ 
 5 
 6 package cn.sxt.test;
 7 
 8 import java.io.BufferedInputStream;
 9 import java.io.BufferedOutputStream;
10 import java.io.FileInputStream;
11 import java.io.FileOutputStream;
12 import java.io.IOException;
13 
14 
15 public class Test_0330_Buffered {
16     public static void main(String[] args) throws IOException {
17         /*File file=new File("poem.txt");
18         InputStream iStream=new FileInputStream(file);*/
19         //帶緩沖的輸入流 緩沖區(qū)為8KB 8192B (8192個(gè)字節(jié))
20         FileInputStream file=new FileInputStream("poem.txt");
21         BufferedInputStream iStream=new BufferedInputStream(file);
22 
23         FileOutputStream file2=new FileOutputStream("poem2.txt");
24         BufferedOutputStream oStream=new BufferedOutputStream(file2);
25         long  b=System.currentTimeMillis();//獲取系統(tǒng)當(dāng)前時(shí)間
26         int len;
27         while ( (len=iStream.read()) !=-1) {
28             oStream.write(len);    //當(dāng)調(diào)用read()或write()方法時(shí) 首先將讀寫的數(shù)據(jù)存入類內(nèi)部定義好8KB的數(shù)組中,然后一次性
29             //讀寫到文件中，類似于前邊自己自定義的大小為1KB的數(shù)組，極大提高讀寫效率
30         }
31         long  c=System.currentTimeMillis();
32         System.out.println("共花費(fèi)："+(c-b)+"毫秒");
33         iStream.close();
34         oStream.close();
35         
36         
37         //不帶緩存緩沖的
38         FileInputStream file3=new FileInputStream("poem.txt");
39         FileOutputStream file4=new FileOutputStream("poem3.txt");
40         
41         long  d=System.currentTimeMillis();//獲取系統(tǒng)當(dāng)前時(shí)間
42         int length;//不帶緩沖區(qū)的，老辦法，讀取一個(gè)字節(jié)，往文件中寫一個(gè)字節(jié)。循環(huán)往復(fù)直到結(jié)束。速度很慢
43         while ( (length=file3.read()) !=-1) {
44             file4.write(length);    
45         }
46         long  e=System.currentTimeMillis();
47         System.out.println("共花費(fèi)："+(e-b)+"毫秒"); //很明顯比帶緩沖區(qū)的花費(fèi)時(shí)間多
48         file3.close();
49         file4.close();
50         
51 
52     }
53 
54 }

?

轉(zhuǎn)載于:https://www.cnblogs.com/ID-qingxin/p/10623587.html

總結(jié)

以上是生活随笔為你收集整理的[19/03/30-星期六] IO技术_四大抽象类_ 字节流( 字节输入流 InputStream 、字符输出流 OutputStream )_(含字节文件缓冲流)...的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。