IO流上：概述、字元流、緩衝區(java基礎)

這個就是暱稱發表於2018-06-13
字元Java

一、IO流概述

概述：

         IO流簡單來說就是Input和Output流，IO流主要是用來處理裝置之間的資料傳輸，Java對於資料的操作都是通過流實現，而java用於操作流的物件都在IO包中。

分類：

        按運算元據分為：位元組流和字元流。 如：Reader和InpurStream

        按流向分：輸入流和輸出流。如：InputStream和OutputStream

IO流常用的基類：

         * InputStream    ，    OutputStream

字元流的抽象基類：

         * Reader       ，         Writer

由上面四個類派生的子類名稱都是以其父類名作為子類的字尾：

            如：FileReader和FileInputStream

二、字元流

1. 字元流簡介：

* 字元流中的物件融合了編碼表，也就是系統預設的編碼表。我們的系統一般都是GBK編碼。

* 字元流只用來處理文字資料，位元組流用來處理媒體資料。

* 資料最常見的表現方式是檔案，字元流用於操作檔案的子類一般是FileReader和FileWriter。

2.字元流讀寫：

注意事項：

* 寫入檔案後必須要用flush()重新整理。

* 用完流後記得要關閉流

* 使用流物件要丟擲IO異常

 

* 定義檔案路徑時，可以用“/”或者“\\”。

* 在建立一個檔案時，如果目錄下有同名檔案將被覆蓋。

* 在讀取檔案時，必須保證該檔案已存在，否則出異常

示例1：在硬碟上建立一個檔案,並寫入一些文字資料

 

[java] view plain copy
 
  1. class FireWriterDemo {  
  2.     public static void main(String[] args) throws IOException {             //需要對IO異常進行處理   
  3.   
  4.         //建立一個FileWriter物件，該物件一被初始化就必須要明確被操作的檔案。  
  5.         //而且該檔案會被建立到指定目錄下。如果該目錄有同名檔案，那麼該檔案將被覆蓋。  
  6.   
  7.         FileWriter fw = new FileWriter("F:\\1.txt");//目的是明確資料要存放的目的地。  
  8.   
  9.         //呼叫write的方法將字串寫到流中  
  10.         fw.write("hello world!");  
  11.       
  12.         //重新整理流物件緩衝中的資料，將資料刷到目的地中  
  13.         fw.flush();  
  14.   
  15.         //關閉流資源，但是關閉之前會重新整理一次內部緩衝中的資料。當我們結束輸入時候，必須close();  
  16.         fw.write("first_test");  
  17.         fw.close();  
  18.         //flush和close的區別：flush重新整理後可以繼續輸入，close重新整理後不能繼續輸入。  
  19.   
  20.     }  
  21. }  

 

示例2：FileReader的reade()方法.

要求：用單個字元和字元陣列進行分別讀取

 

[java] view plain copy
 
  1. class FileReaderDemo {  
  2.     public static void main(String[] args) {  
  3.         characters();  
  4.     }  
  5.   
  6.   
  7. /*****************字元陣列進行讀取*********************/  
  8.     private static void characters() {  
  9.   
  10.         try {  
  11.   
  12.             FileReader fr = new FileReader("Demo.txt");  
  13.             char []  buf = new char[6];   
  14.             //將Denmo中的檔案讀取到buf陣列中。  
  15.             int num = 0;      
  16.             while((num = fr.read(buf))!=-1) {  
  17.   
  18.                 //String(char[] value , int offest,int count) 分配一個新的String,包含從offest開始的count個字元  
  19.                 sop(new String(buf,0,num));  
  20.             }  
  21.             sop('\n');  
  22.             fr.close();  
  23.         }  
  24.         catch (IOException e) {  
  25.             sop(e.toString());  
  26.         }  
  27.     }  
  28.   
  29.   
  30.   
  31.   
  32.   
  33.   
  34. /*****************單個字母讀取*************************/  
  35.     private static void singleReader() {  
  36.           
  37.         try {  
  38.   
  39.             //建立一個檔案讀取流物件，和指定名稱的檔案關聯。  
  40.             //要保證檔案已經存在，否則會發生異常：FileNotFoundException  
  41.             FileReader fr = new FileReader("Demo.txt");  
  42.   
  43.           
  44.             //如何呼叫讀取流物件的read方法？  
  45.             //read()方法，一次讀取一個字元，並且自動往下讀。如果到達末尾則返回-1  
  46.             int ch = 0;  
  47.             while ((ch=fr.read())!=-1) {  
  48.                 sop((char)ch);  
  49.             }  
  50.             sop('\n');  
  51.             fr.close();  
  52.   
  53.   
  54.             /*int ch = fr.read(); 
  55.             sop("ch=" + (char)ch); 
  56.  
  57.             int ch2 = fr.read(); 
  58.             sop("ch2=" + (char)ch2); 
  59.  
  60.             //使用結束注意關閉流 
  61.             fr.close(); */    
  62.               
  63.   
  64.   
  65.         }  
  66.         catch (IOException e) {  
  67.             sop(e.toString());  
  68.         }  
  69.       
  70.     }  
  71.   
  72.   
  73. /**********************Println************************/  
  74.     private static void sop(Object obj) {  
  75.         System.out.print(obj);  
  76.     }  
  77.   
  78. }  

 

示例3：對已有檔案的資料進行續寫

 

 

[java] view plain copy
 
  1. import java.io.*;  
  2.   
  3. class  FileWriterDemo3 {  
  4.     public static void main(String[] args) {  
  5.           
  6.         try {  
  7.             //傳遞一個引數,代表不覆蓋已有的資料。並在已有資料的末尾進行資料續寫  
  8.             FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);  
  9.             fw.write(" is charactor table?");  
  10.             fw.close();  
  11.         }  
  12.         catch (IOException e) {  
  13.             sop(e.toString());  
  14.         }  
  15.           
  16.     }  
  17.   
  18. /**********************Println************************/  
  19.     private static void sop(Object obj)  
  20.     {  
  21.         System.out.println(obj);  
  22.     }  
  23. }  

 



練習：

將F盤的一個檔案複製到E盤。 

思考：

其實就是將F盤下的檔案資料儲存到D盤的一個檔案中。

步驟：

1.在D盤建立一個檔案，儲存F盤中檔案的資料。
2.定義讀取流和F：盤檔案關聯。
3.通過不斷讀寫完成資料儲存。
4.關閉資源。

原始碼：

 

[java] view plain copy
 
  1. import java.io.*;  
  2. import java.util.Scanner;  
  3.   
  4. class CopyText {  
  5.     public static void main(String[] args) throws IOException {  
  6.         sop("請輸入要拷貝的檔案的路徑:");  
  7.         Scanner in = new Scanner(System.in);  
  8.         String source = in.next();  
  9.         sop("請輸入需要拷貝到那個位置的路徑以及生成的檔名:");  
  10.         String destination = in.next();  
  11.         in.close();  
  12.         CopyTextDemo(source,destination);  
  13.   
  14.     }  
  15.   
  16. /*****************檔案Copy*********************/  
  17.     private static void CopyTextDemo(String source,String destination) {  
  18.   
  19.         try {  
  20.             FileWriter fw = new FileWriter(destination);  
  21.             FileReader fr = new FileReader(source);  
  22.             char []  buf = new char[1024];   
  23.             //將Denmo中的檔案讀取到buf陣列中。  
  24.             int num = 0;      
  25.             while((num = fr.read(buf))!=-1) {  
  26.                                //String(char[] value , int offest,int count) 分配一個新的String,包含從offest開始的count個字元  
  27.                 fw.write(new String(buf,0,num));  
  28.             }  
  29.             fr.close();  
  30.             fw.close();  
  31.         }  
  32.         catch (IOException e) {  
  33.             sop(e.toString());  
  34.         }  
  35.     }  
  36.   
  37.   
  38.   
  39. /**********************Println************************/  
  40.     private static void sop(Object obj) {  
  41.         System.out.println(obj);  
  42.     }  
  43. }  

 

三、緩衝區

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

* 緩衝區的出現時為了提高流的操作效率而出現的.

* 需要被提高效率的流作為引數傳遞給緩衝區的建構函式

* 在緩衝區中封裝了一個陣列，存入資料後一次取出

BufferedReader示例：

讀取流緩衝區提供了一個一次讀一行的方法readline，方便對文字資料的獲取。
readline()只返回回車符前面的字元，不返回回車符。如果是複製的話，必須加入newLine()，寫入回車符

newLine()是java提供的多平臺換行符寫入方法。

 

[java] view plain copy
 
  1. import java.io.*;  
  2.   
  3.   
  4. class BufferedReaderDemo {  
  5.     public static void main(String[] args)  throws IOException {  
  6.   
  7.         //建立一個字元讀取流流物件，和檔案關聯  
  8.         FileReader rw = new FileReader("buf.txt");  
  9.   
  10.         //只要將需要被提高效率的流作為引數傳遞給緩衝區的建構函式即可  
  11.         BufferedReader brw = new BufferedReader(rw);  
  12.   
  13.           
  14.         for(;;) {  
  15.             String s = brw.readLine();  
  16.             if(s==null) break;  
  17.             System.out.println(s);  
  18.         }  
  19.           
  20.         brw.close();//關閉輸入流物件  
  21.   
  22.     }  
  23. }  

 

BufferedWriter示例：

 

[java] view plain copy
 
  1. import java.io.*;  
  2.   
  3.   
  4. class BufferedWriterDemo {  
  5.     public static void main(String[] args)  throws IOException {  
  6.   
  7.         //建立一個字元寫入流物件  
  8.         FileWriter fw = new FileWriter("buf.txt");  
  9.   
  10.         //為了提高字元寫入效率，加入了緩衝技術。  
  11.         //只要將需要被提高效率的流作為引數傳遞給緩衝區的建構函式即可  
  12.         BufferedWriter bfw = new BufferedWriter(fw);  
  13.   
  14.         //bfw.write("abc\r\nde");  
  15.         //bfw.newLine();               這行程式碼等價於bfw.write("\r\n"),相當於一個跨平臺的換行符  
  16.         //用到緩衝區就必須要重新整理  
  17.         for(int x = 1; x < 5; x++) {  
  18.             bfw.write("abc");  
  19.             bfw.newLine();                  //java提供了一個跨平臺的換行符newLine();  
  20.             bfw.flush();  
  21.         }  
  22.   
  23.   
  24.   
  25.         bfw.flush();                                                //重新整理緩衝區  
  26.         bfw.close();                                                //關閉緩衝區，但是必須要先重新整理  
  27.   
  28.         //注意，關閉緩衝區就是在關閉緩衝中的流物件  
  29.         fw.close();                                                 //關閉輸入流物件  
  30.   
  31.     }  
  32. }  

 

2.裝飾設計模式

裝飾設計模式：：：：

要求：自定義一些Reader類，讀取不同的資料(裝飾和繼承的區別)
MyReader //專門用於讀取資料的類
    |--MyTextReader
        |--MyBufferTextReader
    |--MyMediaReader
        |--MyBufferMediaReader
    |--MyDataReader
        |--MyBufferDataReader

如果將他們抽取出來，設計一個MyBufferReader，可以根據傳入的型別進行增強
class MyBufferReader {

    MyBufferReader (MyTextReader text) {}
    MyBufferReader (MyMediaReader media) {}
    MyBufferReader (MyDataReader data) {}
}

但是上面的類擴充性很差。找到其引數的共同型別，通過多型的形式，可以提高擴充性

class MyBufferReader  extends MyReader{
    private MyReader r;                        //從繼承變為了組成模式  裝飾設計模式
    MyBufferReader(MyReader r) {}
}

優化後的體系：
    |--MyTextReader
    |--MyMediaReader
    |--MyDataReader
    |--MyBufferReader        //增強上面三個。裝飾模式比繼承靈活，
                              避免繼承體系的臃腫。降低類與類之間的耦合性

裝飾類只能增強已有的物件，具備的功能是相同的。所以裝飾類和被裝飾類屬於同一個體系

 

 

 

MyBuffereReader類：  自己寫一個MyBuffereReader類，功能與BuffereReader相同

 

[java] view plain copy
 
  1. class MyBufferedReader1  extends Reader{               
  2.     private Reader r;  
  3.     MyBufferedReader1(Reader r){  
  4.         this.r  = r;  
  5.     }  
  6.   
  7.     //一次讀一行資料的方法  
  8.     public String myReaderline()  throws IOException {  
  9.         //定義一個臨時容器，原BufferReader封裝的是字元陣列。  
  10.         //為了演示方便。定義一個StringBuilder容器。最終要將資料變成字串  
  11.         StringBuilder sb = new StringBuilder();  
  12.         int ch = 0;  
  13.         while((ch = r.read()) != -1)  
  14.         {  
  15.             if(ch == '\r')   
  16.                 continue;  
  17.             if(ch == '\n')                    //遇到換行符\n,返回字串  
  18.                 return sb.toString();  
  19.             else  
  20.             sb.append((char)ch);  
  21.         }  
  22.         if(sb.length()!=0)                    //當最後一行不是以\n結束時候，這裡需要判斷  
  23.             return sb.toString();  
  24.         return null;  
  25.     }  
  26.     /* 
  27.     需要覆蓋Reader中的抽象方法close()，read(); 
  28.     */  
  29.     public void close()throws IOException {  
  30.         r.close();  
  31.     }  
  32.   
  33.     public int read(char[] cbuf,int off, int len)throws IOException {   //覆蓋read方法  
  34.         return r.read(cbuf,off,len);  
  35.     }  
  36.   
  37.     public void myClose() throws IOException{  
  38.         r.close();  
  39.     }  
  40.   
  41.   
  42. }  

 

 

 

 

一、位元組流

1.概述：

 

1、位元組流和字元流的基本操作是相同的，但是要想操作媒體流就需要用到位元組流。

2、位元組流因為操作的是位元組，所以可以用來操作媒體檔案。（媒體檔案也是以位元組儲存的）

3、讀寫位元組流：InputStream   輸入流（讀）和OutputStream  輸出流（寫）

4、位元組流操作可以不用重新整理流操作。

5、InputStream特有方法：

        int available();//返回檔案中的位元組個數

注：可以利用此方法來指定讀取方式中傳入陣列的長度，從而省去迴圈判斷。但是如果檔案較大，而虛擬機器啟動分配的預設記憶體一般為64M。當檔案過大時，此陣列長度所佔記憶體空間就會溢位。所以，此方法慎用，當檔案不大時，可以使用。

練習：

需求：複製一張圖片F:\java_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.bmp

 

[java] view plain copy
 
  1. import java.io.*;  
  2.   
  3.   
  4. class CopyPic {  
  5.     public static void main(String[] args){  
  6.         copyBmp();  
  7.         System.out.println("複製完成");  
  8.     }  
  9.   
  10.     public static void copyBmp() {  
  11.   
  12.         FileInputStream fis = null;  
  13.         FileOutputStream fos = null;  
  14.         try {  
  15.             fis = new FileInputStream("F:\\java_Demo\\day9_28\\1.bmp");             //寫入流關聯檔案  
  16.             fos = new FileOutputStream("F:\\java_Demo\\day9_28\\2.bmp");            //讀取流關聯檔案  
  17.             byte[] copy = new byte[1024];  
  18.             int len = 0;  
  19.             while((len=fis.read(copy))!=-1) {  
  20.             fos.write(copy,0,len);  
  21.             }  
  22.         }  
  23.         catch (IOException e) {  
  24.             e.printStackTrace();  
  25.             throw new RuntimeException("複製檔案異常");  
  26.         }  
  27.         finally {  
  28.             try {  
  29.                 if(fis!=null) fis.close();  
  30.             }  
  31.             catch (IOException e) {  
  32.                 e.printStackTrace();  
  33.                 throw new RuntimeException("讀取流");  
  34.             }  
  35.         }  
  36.           
  37.     }  
  38.   
  39. }  

 

2. 位元組流緩衝區

* 位元組流緩衝區跟字元流緩衝區一樣，也是為了提高效率。

注意事項：

1. read()：會將位元組byte()提升為int型值

2. write()：會將int型別轉換為byte()型別，保留最後的8位。

練習：

1.複製MP3檔案   1.MP3 -->  2.MP3

2.自己寫一個MyBufferedInputStream緩衝類，提升複製速度

程式碼：

 

[java] view plain copy
 
  1. import java.io.*;  
  2.   
  3.   
  4. //自己的BufferedInputStream  
  5. class MyBufferedInputStream  {  
  6.     private InputStream in;                         //定義一個流物件  
  7.     private byte [] buf = new byte[1024*4];  
  8.     private int count = 0,pos = 0;  
  9.     public MyBufferedInputStream(InputStream in){  
  10.         this.in = in;  
  11.     }  
  12.   
  13.     public  int MyRead() throws IOException{  
  14.         if(count==0) {              //當陣列裡的資料為空時候，讀入資料  
  15.             count = in.read(buf);  
  16.             pos = 0;  
  17.             byte b = buf[pos];  
  18.             count--;  
  19.             pos++;  
  20.             return b&255;       //提升為int型別，在前面三個位元組補充0。避免1111 1111 1111 1111  
  21.         }  
  22.         else if(count > 0) {  
  23.             byte b = buf[pos];  
  24.             pos++;  
  25.             count--;  
  26.             return b&0xff;      //提升為int型別，在前面三個位元組補充0。避免1111 1111 1111 1111  
  27.         }  
  28.         return -1;  
  29.     }  
  30.   
  31.     public void myClose() throws IOException{  
  32.         in.close();  
  33.     }  
  34.   
  35. }  
  36.   
  37.   
  38.   
  39.   
  40. class BufferedCopyDemo {  
  41.     public static void main(String[] args) {  
  42.         long start = System.currentTimeMillis();  
  43.         copy();  
  44.         long end = System.currentTimeMillis();  
  45.         System.out.println("時間:"+(end-start)+"ms");  
  46.   
  47.   
  48.         start = System.currentTimeMillis();  
  49.         copy1();  
  50.         end = System.currentTimeMillis();  
  51.         System.out.println("時間:"+(end-start)+"ms");  
  52.     }   
  53.   
  54. public static void copy1() {                //    應用自己的緩衝區緩衝資料  
  55.   
  56.         MyBufferedInputStream bis = null;  
  57.         BufferedOutputStream  bos = null;  
  58.         try {  
  59.             bis = new MyBufferedInputStream(new FileInputStream("馬旭東-入戲太深.mp3"));//匿名類，傳入一個InputStream流物件  
  60.             bos = new BufferedOutputStream(new FileOutputStream("3.mp3"));  
  61.             int buf = 0;  
  62.             while((buf=bis.MyRead())!=-1) {  
  63.                 bos.write(buf);  
  64.             }  
  65.         }  
  66.         catch (IOException e) {  
  67.             e.printStackTrace();  
  68.             throw new RuntimeException("複製失敗");  
  69.         }  
  70.         finally {  
  71.             try {  
  72.                 if(bis!=null)  {  
  73.                     bis.myClose();  
  74.                     bos.close();  
  75.                 }  
  76.             }  
  77.             catch (IOException e) {  
  78.                 e.printStackTrace();  
  79.             }  
  80.   
  81.         }  
  82.   
  83.     }  
  84. }   

 

二、流操作規律

1. 鍵盤讀取，控制檯列印。

System.out: 對應的標準輸出裝置：控制檯  //它是PrintStream物件，（PrintStream：列印流。OutputStream的子類）

System.in: 對應的標準輸入裝置：鍵盤     //它是InputStream物件

示例：

 

[java] view plain copy
 
  1. /*================從鍵盤錄入流，列印到控制檯上================*/  
  2.     public static void InOutDemo(){  
  3.         //鍵盤的最常見的寫法  
  4.         BufferedReader bufr = null;  
  5.         BufferedWriter bufw = null;  
  6.         try {  
  7.               
  8.             /*InputStream ips = System.in;        //從鍵盤讀入輸入位元組流 
  9.             InputStreamReader fr = new InputStreamReader(ips);             //將位元組流轉成字元流 
  10.             bufr = new BufferedReader(fr);  */                 //將字元流加強，提升效率  
  11.   
  12.               
  13.             bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名類。InputSteamReader:讀取位元組並將其解碼為字元  
  14.             bufw = new BufferedWriter(new OutputStreamWriter(System.out));      //OutputStreamWriter:要寫入流中的字元編碼成位元組  
  15.             String line = null;  
  16.             while((line = bufr.readLine())!=null){  
  17.                 if("over".equals(line)) break;  
  18.                 bufw.write(line.toUpperCase());                     //列印  
  19.                 bufw.newLine();                                     //為了相容，使用newLine()寫入換行符  
  20.                 bufw.flush();                                       //必須要重新整理。不然不會顯示  
  21.             }  
  22.             if(bufw!=null) {  
  23.                 bufr.close();  
  24.                 bufw.close();  
  25.             }  
  26.         }  
  27.         catch (IOException e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.               
  31.           
  32.     }  
  33. }  

 



2. 整行錄入

1.從鍵盤錄入資料，並儲存到檔案中。

2. 我們在鍵盤錄入的是時候，read()方法是一個一個錄入的，能不能整行的錄入呢？這時候我們想到了BufferedReader中ReadLine()方法。

3. 轉換流

為了讓位元組流可以使用字元流中的方法，我們需要轉換流。

 1. InputStreamReader:位元組流轉向字元流；

  a、獲取鍵盤錄入物件。

              InputStream in=System.in;

  b、將位元組流物件轉成字元流物件，使用轉換流。

              InputStreamReaderisr=new InputStreamReader(in);

  c、為了提高效率，將字串進行緩衝區技術高效操作。使用BufferedReader

              BufferedReaderbr=new BufferedReader(isr);

//鍵盤錄入最常見寫法

              BufferedReaderin=new BufferedReader(new InputStreamReader(System.in));

2.OutputStreamWriter:字元流通向位元組流

示例：

 

[java] view plain copy
 
  1. /*================把鍵盤錄入的資料存到一個檔案中==============*/  
  2.     public static void inToFile() {  
  3.             //鍵盤的最常見的寫法  
  4.         BufferedReader bufr = null;  
  5.         BufferedWriter bufw = null;  
  6.         try {  
  7.               
  8.             /*InputStream ips = System.in;        //從鍵盤讀入輸入位元組流 
  9.             InputStreamReader fr = new InputStreamReader(ips);             //將位元組流轉成字元流 
  10.             bufr = new BufferedReader(fr);  */                 //將字元流加強，提升效率  
  11.   
  12.               
  13.             bufr = new BufferedReader(new InputStreamReader(System.in));            //匿名類。InputSteamReader:讀取位元組並將其解碼為字元  
  14.             bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));     //OutputStreamWriter:要寫入流中的字元編碼成位元組  
  15.             String line = null;  
  16.             while((line = bufr.readLine())!=null){  
  17.                 if("over".equals(line)) break;  
  18.                 bufw.write(line.toUpperCase());                     //列印  
  19.                 bufw.newLine();                                     //為了相容，使用newLine()寫入換行符  
  20.                 bufw.flush();                                       //必須要重新整理。不然不會顯示  
  21.             }  
  22.             if(bufw!=null) {  
  23.                 bufr.close();  
  24.                 bufw.close();  
  25.             }  
  26.         }  
  27.         catch (IOException e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.               
  31.   
  32.     }  


 

4. 流操作基本規律

為了控制格式我將其寫入了Java程式碼段中，如下：

示例1：文字 ~ 文字

 

 

[java] view plain copy
 
  1. /*  
  2. 流操作的基本規律。  
  3. 一、兩個明確：(明確體系)  
  4. 1. 明確源和目的  
  5.     源：輸入流  InputStream  Reader  
  6.     目的：輸出流  OutputStream Writer  
  7.   
  8. 2. 操作的資料是否是純文字  
  9.     是： 字元流  
  10.     否： 位元組流  
  11. 二、明確體系後要明確具體使用的物件  
  12.     通過裝置區分：記憶體，硬碟，鍵盤  
  13.     目的裝置：記憶體，硬碟，控制檯  
  14.   
  15.   
  16. 示例1：將一個文字檔案中的資料儲存到另一個檔案中: 複製檔案  
  17.     一、明確體系  
  18.         源：檔案-->讀取流-->(InputStream和Reader)  
  19.         是否是文字：是-->Reader  
  20.           
  21.           
  22.         目的：檔案-->寫入流-->(OutputStream Writer)  
  23.         是否純文字：是-->Writer  
  24.       
  25.     二、 明確裝置  
  26.         源：Reader  
  27.             裝置：硬碟上一個文字檔案 --> 子類物件為：FileReader  
  28.                 FileReader fr = new FileReader("Goods.txt");  
  29.               
  30.             是否提高效率：是-->加入Reader中的緩衝區：BufferedReader  
  31.                 BufferedReader bufr = new BufferedReader(fr);  
  32.                   
  33.         目的：Writer  
  34.             裝置：鍵盤上一個文字檔案 --> 子類物件：FileWriter  
  35.                 FileWriter fw = new FileWriter("goods1.txt");  
  36.             是否提高效率：是-->加入Writer的緩衝區：BufferedWriter  
  37.                 BufferedWriter bufw = new BufferedWriter(fw);  
  38.               
  39.               
  40.               
  41. 示例2：將一個圖片檔案資料複製到另一個檔案中：複製檔案  
  42.     一、明確體系  
  43.         源：檔案-->讀取流-->(InputStream和Reader)  
  44.         是否是文字：否-->InputStream  
  45.           
  46.           
  47.         目的：檔案-->寫入流-->(OutputStream Writer)  
  48.         是否純文字：否-->OutputStream  
  49.       
  50.     二、 明確裝置  
  51.         源：InputStream  
  52.             裝置：硬碟上一個媒體檔案 --> 子類物件為：FileInputStream  
  53.                 FileInputStream fis = new FileInputStream("Goods.txt");  
  54.               
  55.             是否提高效率：是-->加入InputStream中的緩衝區：BufferedInputStream  
  56.                 BufferedInputStream bufi = new BufferedInputStream(fis);  
  57.                   
  58.         目的：OutputStream  
  59.             裝置：鍵盤上一個媒體檔案 --> 子類物件：FileOutputStream  
  60.                 FileOutputStream fos = new FileOutputStream("goods1.txt");  
  61.             是否提高效率：是-->加入OutputStream的緩衝區：BufferedOutputStream  
  62.                 BufferedOutputStream bufo = new BufferedOutputStream(fw);  
  63.   
  64. 示例3：將鍵盤錄入的資料儲存到一個文字檔案中  
  65.     一、明確體系  
  66.         源：鍵盤-->讀取流-->(InputStream和Reader)  
  67.         是否是文字：是-->Reader  
  68.           
  69.           
  70.         目的：檔案-->寫入流-->(OutputStream Writer)  
  71.         是否純文字：是-->Writer  
  72.       
  73.     二、 明確裝置  
  74.         源：InputStream  
  75.             裝置：鍵盤 --> 對用物件為：System.in --> InputStream  
  76.                 為了操作方便，轉成字元流Reader --> 使用Reader中的轉換流：InputStreamReader  
  77.                 InputStreamReader isr = new InputStreamReader(System.in);  
  78.               
  79.             是否提高效率：是-->加入Reader中的緩衝區：BufferedReader  
  80.                 BufferedReader bufr = new BufferedReader(isr);  
  81.                   
  82.         目的：Writer  
  83.             裝置：鍵盤上一個文字檔案 --> 子類物件：FileWriter  
  84.                 FileWriter fw = new FileWriter("goods1.txt");  
  85.             是否提高效率：是-->加入Writer的緩衝區：BufferedWriter  
  86.                 BufferedWriter bufw = new BufferedWriter(fw);  

5.指定編碼表(轉換流可以指定編碼表)

要求：用UTF-8編碼儲存一個文字檔案

 

[java] view plain copy
 
  1. import java.io.*;  
  2. public class IOStreamLaw {  
  3.   
  4.     /** 
  5.      * @param args 
  6.      */  
  7.     public static void main(String[] args) throws IOException {  
  8.                 //鍵盤的最常見寫法  
  9.                 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
  10.                 BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));  
  11.                 String line = null;  
  12.                 while((line=bufr.readLine())!=null){  
  13.                     if("over".equals(line)) break;  
  14.                     bufw.write(line.toUpperCase());  
  15.                     bufw.newLine();  
  16.                     bufw.flush();  
  17.                 }  
  18.                 bufr.close();  
  19.     }  
  20.   
  21.   
  22. }  

相關文章