Java中流-----我的總結心得

流

1. 字符流

2. 字節流

3. 緩衝區

數據流---用於傳輸數據。IO流---Input/Output流。數據從外部流向程序---輸入流；數據從程序流向外部的時候--輸出流。讀取一個文件---數據從文件流向程序---輸入流；向一個文件中寫入數據---數據從程序流向文件---輸出流

根據數據流動的方向：輸入流/輸出流

根據數據傳輸的形式：字節流/字符流

	輸入流	輸出流
字節流	InputStream	OutputSteam
字符流	Reader	Writer

 

這四個類是Java中四個流的基本類，可是這四個類都是抽象類，都不能用於直接建立對象

數據的來源：硬盤、網絡、內存、輸入設備

向一個文件中去寫入數據---txt文件---字符流、輸出流、文件流---

最簡單的一個輸入流，寫入緩衝區中，再從緩衝區中讀取出來

 1 public static void main(String[] args) throws IOException {
 2         // TODO Auto-generated method stub
 3         String c;                    //設置一個字符串去接收緩衝區
 4         InputStreamReader IsReader=new InputStreamReader(System.in);//輸入流：鍵盤輸入
 5         BufferedReader bReader=new BufferedReader(IsReader);//將輸入的存入緩衝區中
 6         System.out.println("輸入字符按q退出");
 7         do {
 8             c= bReader.readLine();//從緩衝區中讀取
 9             System.out.println(c);
10         } while (!c.equals("q"));
11     }

 字符流

FileWriter

構造函數

FileWriter(String name)--傳入文件路徑，操做對應的文件---當文件不存在的時候，會建立這個文件；若是文件存在，則建立一個新文件覆蓋源文件。

重要方法

write(String s)---寫出字符串。數據不是直接寫到目的地而是寫到緩衝區中，等到緩衝區滿了以後纔會寫到目的地中

flush()---沖刷緩衝區

close()---關閉流。流在關閉以前會自動的沖刷緩衝區。

代碼實現：

 1  public static void main(String[] args) throws IOException {   
 2           //建立一個FileWriter對象，並指定文件路徑，該文件會被建立到指定目錄下。若是該目錄有同名文件，那麼該文件將被覆蓋。 
 3             FileWriter fw = new FileWriter("1.txt");
 4             //調用write的方法將字符串寫到流中  
 5             fw.write("hello world!");  
 6             //刷新流對象緩衝中的數據，將數據刷到目的地中  
 7             fw.flush();  
 8             //關閉流資源，可是關閉以前會刷新一次內部緩衝中的數據。當咱們結束輸入時候，必須close();  
 9             fw.write("刷新");  
10             fw.close();  
11             //flush和close的區別：flush刷新後能夠繼續輸入，close刷新後不能繼續輸入。  
12         }  

 

流的異常處理

1. 流對象要外置定義內置初始化

2. 判斷流對象是否初始化成功---判斷流對象是否爲空

3. 關流操做不管成功與否，都須要將流對象值爲null

FileReader

 

1	public int read() throws IOException 讀取單個字符，返回一個int型變量表明讀取到的字符
2	public int read(char [] c, int offset, int len) 讀取字符到c數組，返回讀取到字符的個數

 

代碼實現：

 1      public static void main(String[] args) throws IOException {   
 2          //建立FileReader對象，並讀取1.txt文件
 3          FileReader fr = new FileReader("1.txt"); 
 4          //單字符讀取  。。。。。。多字符的讀取，建立數組將1.txt文件存入數組中，在讀取出來char []  buf = new char[6];   
 5          int ch = 0;     
 6        //一直讀取文件中的內容直到文件的尾部
 7          while((ch = fr.read())!=-1) {  
 8             /* 輸出字符串   
 9              * 
10              * String(char[] value , int offest,int count) 分配一個新的String,包含從offest開始的count個字符 new String(buf,0,ch}
11              * */ 
12             System.out.print((char)ch);  
13          }  
14          fr.close();  //關閉流
15         }  

 兩個結合能夠實現一個文件的拷貝

將1.txt文件內容拷貝到2.txt中

代碼實現：

 1      public static void main(String[] args) throws IOException {   
 2          FileReader fr=new FileReader("1.txt");//先讀取須要拷貝的文件
 3          FileWriter fw=new FileWriter("2.txt");//拷貝文件內容複製到的另個文件路徑
 4          int ch=0;   
 5          while ((ch=fr.read())!=-1) {   //讀個讀取內容
 6             fw.write((char)ch);   //將讀取的內容寫入文件中
 7         }
 8          fr.close();  //關閉讀取流
 9          fw.close();//關閉寫入流
10      }

 

字節流

其實字節流和字符流是差很少的形式，看懂了上面，下面就不用多說了

文件輸入流： FileInputStream類

 簡要的說是打開文件，將文件數據讀取到內存中

代碼實現：

1 public static void main(String[] args) throws IOException {   
2              FileInputStream fStream=new FileInputStream("1.txt");//建立文件輸入流對象
3              int ch=0;
4              while ((ch=fStream.read())!=-1) {   //依次讀取文件內容賦值給ch
5                 System.out.print((char)ch);     //輸出內容-----(char)ch轉換成字符輸出
6             }
7              }

文件輸出流: FileOutputStream類

目的是將內存中的數據讀取到文件中

代碼實現：

 1      public static void main(String[] args) throws IOException {   
 2          int count, n = 20;  
 3          //建立字節數組
 4          byte buffer[] = new byte[n]; 
 5          //將輸入的字節存入字節數組中
 6          count = System.in.read(buffer);//System.in.read()返回的是輸入數值的 ASKII 碼（一個 int 整數）
 7          FileOutputStream fO=new FileOutputStream("1.txt"); //建立文件輸出流對象，指定文件路徑
 8          fO.write(buffer, 0, count); //將字節寫入文件，顯示字符
 9          fO.close();//關閉流
10      }

 FileInputStream流和FileOutputStream的應用

將1.txt文件拷貝到2.txt 文件中

代碼實現：

 1  public static void main(String[] args) throws IOException {   
 2          FileInputStream fIn=new FileInputStream("1.txt");//建立文件輸入流對象  拷貝對象文件，指定文件路徑
 3          FileOutputStream fOut=new FileOutputStream("2.txt");//建立文件輸出流對象，，指定寫入內容的文件路徑
 4          int ch=0;
 5          while ((ch=fIn.read())!=-1) {//循環讀取
 6             fOut.write(ch);//將內容寫入
 7         }
 8          fIn.close();//關閉流
 9          fOut.close();//關閉流
10      }

 

OutputStreamWriter---將一個字節輸出流轉化爲字符輸出流

 代碼演示：

1      public static void main(String[] args) throws IOException {   
2          String string="sadkjsdfadsfdaasd";        //須要寫入的字符串
3          FileOutputStream fStream=new FileOutputStream("1.txt");//建立輸出流對象，指定寫入文件的路徑
4          OutputStreamWriter oWriter=new OutputStreamWriter(fStream, "utf-8");//-將一個字節輸出流轉化爲字符輸出流 ---能夠指定編碼格式utf-8
5          oWriter.write(string);//寫入文件內容
6          fStream.close();//關閉字節輸出流
7         oWriter.close();//關閉字符輸出流
8 }

 

InputStreamReader---將一個字節輸入流轉化爲字符輸入流

代碼演示：

1      public static void main(String[] args) throws IOException {   
2          FileInputStream  fStream=new FileInputStream("1.txt");//建立輸入流對象，並指定讀取文件路徑
3          InputStreamReader iReader=new InputStreamReader(fStream);//將一個字節輸入流轉化爲字符輸入流
4         StringBuffer sBuffer=new StringBuffer(); //建立一個字符串接收
5          while (iReader.ready()) { //讀取字符輸入流內容
6             sBuffer.append((char)iReader.read());//添加到字符中
7         }
8          System.out.println(sBuffer.toString());//輸出顯示
　　　　　　fStream.close();//關閉字節輸入流
　　　　　　iReader.close(); //關閉字符輸入流

9      }

 

 

OutputStreamWriter和InputStreamReader結合應用

將1.txt中的數據讀取到內存，在從內存中數據讀取到2.txt

代碼演示：

 public static void main(String[] args) throws IOException {   
         FileInputStream fStream=new FileInputStream("1.txt"); 
         InputStreamReader iReader=new InputStreamReader(fStream);
         FileOutputStream fStream2=new FileOutputStream("2.txt");
         OutputStreamWriter oWriter=new OutputStreamWriter(fStream2, "utf-8");
         while (iReader.ready()) {
            oWriter.write((char)iReader.read()); //將輸入字符流給輸出字符流，寫入文件中
            oWriter.flush(); //這是個循環須要刷新緩存
        }
         iReader.close();//關閉流
         oWriter.close();
         fStream.close();
         fStream2.close();
}

將內存數據寫入文件1.txt，在從文件1.txt中的數據讀取出來到內存中

代碼演示：

 1 public static void main(String[] args) throws IOException {   
 2          String string="style周";
 3          FileOutputStream fOutputStream=new FileOutputStream("1.txt");
 4          OutputStreamWriter oWriter=new OutputStreamWriter(fOutputStream,"utf-8");//建立字符輸出流，設置字符編碼
 5          oWriter.write(string);          //將字符串寫入字符輸出流中，寫入文件
 6          oWriter.close();        //關閉流
 7          fOutputStream.close();
 8          FileInputStream fInputStream=new FileInputStream("1.txt");
 9          InputStreamReader iReader=new InputStreamReader(fInputStream,"utf-8");//建立字符輸入流，字符編碼設置
10          StringBuffer sBuffer=new StringBuffer();    //設置一個字符變量接收
11          while (iReader.ready()) {
12             sBuffer.append((char)iReader.read());   //添加到字符串中
13         }
14          iReader.close();//關閉流
15          fInputStream.close();
16          System.out.println(sBuffer);
17 }

這裏我須要講解一下flush用法

 flush的做用是用於在數據緩存中數據滿了以後刷新該緩存，而後對剩下的數據繼續進行緩存。若是要寫入的數據量很小，或者你本身定義的緩存足夠大到能夠保存全部數據的話，不用flush也不會丟失數據，可是若是要寫入的數據大小操做緩存大小，則須要循環多步才能處理完，這時不用flush就會致使只有最前面的一些數據可以寫入，而剩下的數據會丟失。只有字符流纔有刷新

緩衝區

        計算機訪問外部設備很是耗時。訪問外存的頻率越高，形成CPU閒置的機率就越大。爲了減小訪問外存的次數，應該在一次對外設的訪問中，讀寫更多的數據。爲此，除了程序和流節點間交換數據必需的讀寫機制外，還應該增長緩衝機制。緩衝流就是每個數據流分配一個緩衝區，一個緩衝區就是一個臨時存儲數據的內存。這樣能夠減小訪問硬盤的次數,提升傳輸效率。  

1. 字符流的緩衝區：BufferedReader和BufferedWreiter

* 緩衝區的出現時爲了提升流的操做效率而出現的.

* 須要被提升效率的流做爲參數傳遞給緩衝區的構造函數

* 在緩衝區中封裝了一個數組，存入數據後一次取出

BufferedReader

自帶了緩衝區，須要一個Reader對象來構建這個BufferedReader對象---BufferedReader最主要的做用提供緩衝區，從字符輸入流中來獲取數據；Reader對象來指名數據的具體來源

簡單代碼實現：

 1  public static void main(String[] args) throws IOException {   
 2          FileReader fReader=new FileReader("1.txt");//建立一個文件讀取對象，並讀取文件
 3          BufferedReader bReader=new BufferedReader(fReader);//將文件內容放入緩衝區中------  須要被提升效率的流做爲參數傳遞給緩衝區的構造函數
 4          StringBuffer sBuffer=new StringBuffer();   //建立一個StringBuffer類的字符串後面接收讀出的數據
 5          while (bReader.ready()) {  //循環讀取知道文件尾部
 6             sBuffer.append((char)bReader.read());//將文件內容逐一添加到sBuffer中
 7  } 8 System.out.println(sBuffer.toString());//輸出 9 fReader.close();//關閉讀取流 10 bReader.close();//關閉緩衝區讀取流 11 }

 

BufferedWriter

代碼實現：

 1  public static void main(String[] args) throws IOException {   
 2              FileWriter  fWriter=new FileWriter("1.txt");//建立寫入流對象，並指定建立的文件路徑；
 3              BufferedWriter bWriter=new BufferedWriter(fWriter);//建立寫入流的緩衝區
 4              bWriter.write("abcdf");//向緩衝區寫入字符
 5              bWriter.flush(); //刷新緩衝區
 6              bWriter.newLine();//newLine()在不一樣的操做系統下自動轉義爲當前系統認識對的回車換行
 7              bWriter.write("qwer"); 8 bWriter.flush(); //刷新緩衝區 9 bWriter.close();//關閉緩衝區 10 fWriter.close();//關閉寫入流 11 }

字節流緩衝區

BufferedInputStream:當向緩衝流寫入數據時候，數據先寫到緩衝區，待緩衝區寫滿後，系統一次性將數據發送給輸出設備。

 1      public static void main(String[] args) throws IOException {   
 2          FileInputStream fStream=new FileInputStream("1.txt");
 3          BufferedInputStream bStream=new BufferedInputStream(fStream); //字節輸入流緩衝區，，
 4          int ch=0;
 5          while ((ch=bStream.read())!=-1) {
 6             System.out.print((char)ch);
 7         }
 8          fStream.close();//關閉流
 9          bStream.close();
10      }

BufferedOutputStream :當從向緩衝流讀取數據時候，系統先從緩衝區讀出數據，待緩衝區爲空時，系統再從輸入設備讀取數據到緩衝區。

1  public static void main(String[] args) throws IOException {   
2         int ch=1561;//由於寫入的是int類型的，因此用用int，也能夠用    System.in.read()鍵盤輸入字符，轉換成ASKII 碼（一個 int 整數）
3         FileOutputStream fOutputStream=new FileOutputStream("1.txt");
4         BufferedOutputStream bStream=new BufferedOutputStream(fOutputStream);//建立字節輸出流緩衝區對象
5         bStream.write(ch); //將字節寫入文件中
6         bStream.close();//關閉流
7         fOutputStream.close();
8         }

 

系統流/標準流---字節流

底層使用字節流來實現的

System.out   標準輸出流

System.in    標準輸入流

System.err   標準錯誤流