Java基礎之IO技術（一）

---恢復內容開始---

　　Java基礎中的IO技術可謂是很是重要，俗話說的好，萬丈高樓起於壘土之間。因此學習Java必定要把基礎學好，今天咱們來學習IO技術的基礎。

　　IO無非就是輸入與輸出，而其中處理的數據無非是字符與字節。字符最簡單的定義就是這個數據是不是純文本組成，除此以外全部的都是字節。Java給咱們提供了字符和字節的處理，其中字符的處理有Writer和Reader兩個抽象父類（分別對應的是寫和讀），字節的處理有OutputStream和InputStream兩個抽象類（分別對應的是寫和讀）。今天咱們就看看字符的處理。

　　字符的處理

　　1.字符的讀（FileReader）

　　首先請看一段代碼：

 1 import java.io.*;  2 
 3 public class FileReader1 {  4     public static void main(String[] args){  5         FileReader fr = null;  6         try{  7             fr = new FileReader("1.txt");  8             int ch = 0;  9             //read():字符讀取，若是已經達到流的結尾，則爲-1 10             //這個能夠做爲讀取文件結束的條件
11             while((ch = fr.read()) != -1){ 12                 //進行強制轉換
13                 System.out.print((char)ch); 14  } 15             sop("讀取結束"); 16 
17         }catch(FileNotFoundException e){ 18  sop(e.toString()); 19         }catch(IOException e){ 20  sop(e.toString()); 21         }finally{ 22             try { 23                 if(fr != null) { 24  fr.close(); 25  } 26             }catch(IOException e){ 27  sop(e.toString()); 28  } 29  } 30  } 31     public static void sop(Object obj){ 32  System.out.println(obj); 33  } 34 }

 

　　這是文件讀取的第一種方法，這種方法是將文件中的數據一個一個的讀出來，這樣操做比較耗資源，所以有了第二種讀取方法，請看下面這段代碼。

 1 import java.io.*;  2 
 3 public class FileReader2 {  4     public static void main(String[] args){  5         FileReader fr = null;  6         try{  7             fr = new FileReader("1.txt");  8             //read(char[] cbuf):將字符讀取到數組中  9             //這個數組大小1024整數倍
10             char[] buff = new char[1024]; 11             int num = 0; 12             while((num = fr.read(buff)) != -1){ 13                 sop(new String(buff, 0, num)); 14  } 15 
16         }catch(FileNotFoundException e){ 17  sop(e.toString()); 18         }catch(IOException e){ 19  sop(e.toString()); 20         }finally{ 21             try{ 22                 if(fr != null) { 23  fr.close(); 24  } 25             }catch(IOException e){ 26  sop(e.toString()); 27  } 28  } 29 
30  } 31     public static void sop(Object obj){ 32  System.out.println(obj); 33  } 34 }

 

　　這種方法是利用一個數組（這個數組大小通常定義爲1024的整數倍），將文件中的數據傳入到一個數組中，而後將數組中的數據一次性的處理。顯而易見這種方法更好。

　　文件打開是須要關閉的，經過close方法。

 

　　2.字符的寫（FileWriter）

　　首先請看下面一段代碼

 1 import java.io.*;  2 
 3 public class FileWriterDemo {  4     public static void main(String[] args){  5  fileWriter();  6 
 7  }  8     public static void fileWriter(){  9         FileWriter fw = null; 10         try { 11             fw = new FileWriter("1.txt"); 12 
13             fw.write("asdsadasdafd"); 14  fw.flush(); 15 
16             fw.append("\n"+123); 17  fw.flush(); 18 
19         }catch(IOException e){ 20  sop(e.toString()); 21         }finally{ 22             try{ 23                 if(fw != null) { 24  fw.close(); 25  } 26             }catch(IOException e){ 27  sop(e.toString()); 28  } 29  } 30  } 31     public static void sop(Object obj){ 32  System.out.println(obj); 33  } 34 }

 

　　首先對象的創立，有多個構造函數。這裏我介紹兩種，FileWriter(String fileName)和FileWriter(String fileName, boolean append)。在第二個構造函數中有一個布爾型參數，爲false就和第一個構造函數同樣，每次向目的地中寫入數據時都會覆蓋原來的數據，若不想覆蓋原來的數據，可使用append方法；爲true時，就不會覆蓋原來的數據，而是在原數據後面追加數據。

　　文件的寫入是經過一個緩衝區（爲了解決cpu和硬盤速度並不匹配的問題），所以在寫入一段數據後，要經過flush方法刷新緩衝區，將數據送到目的地中（文件）。最後經過close方法關閉資源，在關閉以前也會刷新緩衝區。每次向目的地寫入數據時，都會檢測是否有目的文件，若沒有則建立一個。

　　爲提升數據的讀寫效率，Java中提供了緩衝技術，對原來的FileWriter與FileReader進行修飾，其中涉及到了修飾設計模式，這裏就不具體講解。下面就對緩衝技術進行講解。

 

　　3.修飾後的寫（BufferedWriter）

　　咱們仍是來看看具體代碼

 1 import java.io.*;  2 
 3 public class BufferedWriterDemo {  4     public static void main(String[] args){  5         //建立一個字符寫入流對象
 6         FileWriter fw = null;  7         BufferedWriter bw = null;  8         try{  9             fw = new FileWriter("2.txt", true); 10             //爲提升字符寫入的流效率，加入了緩衝技術。 11             //只要將須要提升效率的流對象做爲參數傳遞給緩衝區的構造函數
12             bw = new BufferedWriter(fw); 13             for(int i=0; i<5; i++) { 14                 bw.write("sdadadas"+i); 15  bw.newLine(); 16  } 17             //記住，只要用到緩衝區就要刷新
18  bw.flush(); 19 
20         }catch(IOException e){ 21  sop(e.toString()); 22 
23         }finally { 24             try{ 25                 //其實關閉緩衝區，就是在關閉與緩衝區關聯的流對象
26  bw.close(); 27             }catch(IOException e){ 28  sop(e.toString()); 29  } 30  } 31 
32 
33  } 34     private static void sop(Object obj){ 35  System.out.println(obj); 36  } 37 }

 

　　這一段知識盡在代碼與註釋中。其中有一個newLine方法，讓咱們看看1.8api中解釋（寫一行行分隔符。 行分隔符字符串由系統屬性line.separator定義，並不必定是單個換行符（'\ n'）字符）。在不一樣系統中，換行符都不一樣。而使用了這個方法後，一樣的代碼不會在不一樣的系統中出現亂碼的問題。

　　最後的close方法，有一個疑問（究竟是使用流對象的close方法仍是使用緩衝技術的close方法呢），首先咱們回到一開始，緩衝技術是用來修飾流操做的，必然他們操做的是流。所以使用其中任何一個close方法都會關閉這個流資源。

 

　　4.修飾後的讀（BufferedReader）

　　請看下一段代碼

 

 1 import java.io.*;  2 
 3 public class BufferedReaderDemo {  4     public static void main(String[] args){  5         FileReader fr = null;  6         BufferedReader br = null;  7         try{  8             //建立一個讀取流對象並與文件關聯
 9             fr = new FileReader("2.txt"); 10             //爲了提升效率，加入了緩衝區技術。將字符讀取流對象做爲參數傳入到緩衝對象的構造函數
11             br = new BufferedReader(fr); 12 
13             String line = null; 14             while((line = br.readLine()) != null){ 15  sop(line); 16  } 17 
18         }catch(FileNotFoundException e){ 19  sop(e.toString()); 20         }catch(IOException e){ 21  sop(e.toString()); 22         }finally { 23             try{ 24                 if(br != null){ 25  br.close(); 26  } 27             }catch(IOException e){ 28  sop(e.toString()); 29  } 30  } 31  } 32 
33     private static void sop(Object obj){ 34  System.out.println(obj); 35  } 36 }

　　

　　這段知識的原理和上一段的知識相似，就不作具體的解釋了。就說說其中的readLine方法，咱們來看看api文檔，public String readLine()，（讀一行文字。 一行被視爲由換行符（'\ n'），回車符（'\ r'）中的任何一個或隨後的換行符終止），也就是說把文件中的一行數據讀取出來。

　　咱們總結一下字符的體系

 1 /**
 2  * 讀：  3  * Reader  4  * |--FileReader（兩種讀的方法，資源的關閉）  5  * |--BufferedReader（修飾設計模式，高效的處理方式，readLine方法，close方法關閉資源）  6  *  7  * 寫：  8  * Writer  9  * |--FileWriter（兩種構造方法，write方法與append方法，） 10  * |--BufferedWriter（修飾設計模式，高效的處理方式，newLine方法，close方法關閉資源） 11  * 12  * 13  * */

 

 

 

　　今天只講解了字符的操做，關於字節的操做和其餘IO的基礎知識，在後面會相應的推出。

 

 

 

 

---恢復內容結束---