Java輸入輸出流詳解及應用實例

       Java的I/O系統中的輸入輸出流為我們進行開發提供了很多便利，利用其強大的封裝性，通過各種組合能夠實現多種多樣的功能。但是Java提供了很多輸入輸出流類，在概念和使用上有很多相似之處，所以給很多開發者帶來了困擾，何時應該用何種輸入輸出流類成為一個問題。

       以下即是Java輸入輸出流類的介紹，並附有實例說明，對各個類的用法都有簡要分析。

       輸入輸出流類介紹

      1.stream代表的是任何有能力產出數據的數據源，或是任何有能力接收數據的接收源。在Java的IO中，所有的stream（包括Input和Out   stream）都包括兩種類型： 以字節為導向的stream和以Unicode字符為導向的stream。

       1.1 以字節為導向的stream 

       以字節為導向的stream，表示以字節為單位從stream中讀取或往stream中寫入信息。以字節為導向的stream包括下面幾種類型： 

       input　stream： 

       1)   ByteArrayInputStream：把內存中的一個緩沖區作為InputStream使用
       2)   StringBufferInputStream：把一個String對象作為InputStream
       3)   FileInputStream：把一個文件作為InputStream，實現對文件的讀取操作
       4)   PipedInputStream：實現了pipe的概念，主要在線程中使用
       5)   SequenceInputStream：把多個InputStream合並為一個InputStream 

       Out　stream：

       1)   ByteArrayOutputStream：把信息存入內存中的一個緩沖區中
       2)   FileOutputStream：把信息存入文件中
       3)   PipedOutputStream：實現了pipe的概念，主要在線程中使用
       4)   SequenceOutputStream：把多個OutStream合並為一個OutStream 

       1.2 以Unicode字符為導向的stream 

       以Unicode字符為導向的stream，表示以Unicode字符為單位從stream中讀取或往stream中寫入信息。以Unicode字符為導向的stream包括下面幾種類型： 

       Input　Stream：

       1)   CharArrayReader：與ByteArrayInputStream對應
       2)   StringReader：與StringBufferInputStream對應
       3)   FileReader：與FileInputStream對應
       4)   PipedReader：與PipedInputStream對應 

       Out　Stream：

       1)   CharArrayWrite：與ByteArrayOutputStream對應
       2)   StringWrite：無與之對應的以字節為導向的stream
       3)   FileWrite：與FileOutputStream對應
       4)   PipedWrite：與PipedOutputStream對應 

       以字符為導向的stream基本上對有與之相對應的以字節為導向的stream。兩個對應類實現的功能相同，字是在操作時的導向不同。如CharArrayReader：和ByteArrayInputStream的作用都是把內存中的一個緩沖區作為InputStream使用，所不同的是前者每次從內存中讀取一個字節的信息，而後者每次從內存中讀取一個字符。

       1.3 兩種不現導向的stream之間的轉換 

       InputStreamReader和OutputStreamReader：把一個以字節為導向的stream轉換成一個以字符為導向的stream。 

       2.為stream添加屬性 

       2.1 "為stream添加屬性”的作用 

       運用上面介紹的Java中操作IO的API，我們就可完成我們想完成的任何操作了。但通過FilterInputStream和FilterOutStream的子類，我們可以為stream添加屬性。下面以一個例子來說明這種功能的作用。 如果我們要往一個文件中寫入數據，我們可以這樣操作： 

       FileOutStream   fs   =   new   FileOutStream(“test.txt”); 

       然後就可以通過產生的fs對象調用write()函數來往test.txt文件中寫入數據了。但是，如果我們想實現“先把要寫入文件的數據先緩存到內存中，再把緩存中的數據寫入文件中”的功能時，上面的API就沒有一個能滿足我們的需求了。但是通過FilterInputStream和FilterOutStream的子類，為FileOutStream添加我們所需要的功能。 

       2.2   FilterInputStream的各種類型 

       2.2.1   用於封裝以字節為導向的InputStream 

       1)   DataInputStream：從stream中讀取基本類型（int、char等）數據。
       2)   BufferedInputStream：使用緩沖區
       3)   LineNumberInputStream：會記錄input   stream內的行數，然後可以調用getLineNumber()和setLineNumber(int)
       4)   PushbackInputStream：很少用到，一般用於編譯器開發

       2.2.2   用於封裝以字符為導向的InputStream 

       1)   沒有與DataInputStream對應的類。除非在要使用readLine()時改用BufferedReader，否則使用DataInputStream
       2)   BufferedReader：與BufferedInputStream對應
       3)   LineNumberReader：與LineNumberInputStream對應
       4)   PushBackReader：與PushbackInputStream對應

       2.3   FilterOutStream的各種類型 

       2.2.3   用於封裝以字節為導向的OutputStream 

       1)   DataOutputStream：往stream中輸出基本類型（int、char等）數據。
       2)   BufferedOutStream：使用緩沖區
       3)   PrintStream：產生格式化輸出 

       2.2.4   用於封裝以字符為導向的OutputStream 

       1)   BufferedWrite：與BufferedOutStream對應 
       2)   PrintWrite：與PrintStream對應 

       3.   RandomAccessFile 

       1)   可通過RandomAccessFile對象完成對文件的讀寫操作
       2)   在產生一個對象時，可指明要打開的文件的性質：r，只讀；w，只寫；rw可讀寫
       3)   可以直接跳到文件中指定的位置 

       輸入輸出流應用實例

      下面在main函數中給出6個代碼段，說明各個輸入輸出流類的使用方法，並在代碼段後有相應注釋說明。

1. import   java.io.*;    
2. public   class   TestIO{    
3. public   static   void   main(String[]   args)    
4. throws   IOException{    
5.   
6. //1.以行為單位從一個文件讀取數據    
7. BufferedReader   in   =      
8. new   BufferedReader(    
9. new   FileReader( "F:\\nepalon\\TestIO.java "));    
10. String   s,   s2   =   new   String();    
11. while((s   =   in.readLine())   !=   null)    
12. s2   +=   s   +   "\n ";    
13. in.close();    
14. // 當讀取文件時，先把文件內容讀到緩存中，當調用in.readLine()時，再從緩存中以字符的方式讀取數據（以下簡稱“緩存字節讀取方式”）。   
15.   
16. //1b.   接收鍵盤的輸入    
17. BufferedReader   stdin   =      
18. new   BufferedReader(    
19. new   InputStreamReader(System.in));    
20. System.out.println( "Enter   a   line: ");    
21. System.out.println(stdin.readLine());    
22. // 由於想以緩存字節讀取方式從標准IO（鍵盤）中讀取數據，所以要先把標准IO（System.in）轉換成字符導向的stream，再進行BufferedReader封裝。   
23.   
24. //2.   從一個String對象中讀取數據    
25. StringReader   in2   =   new   StringReader(s2);    
26. int   c;    
27. while((c   =   in2.read())   !=   -1)    
28. System.out.println((char)c);    
29. in2.close();    
30. // 要以字符的形式從一個String對象中讀取數據，所以要產生一個StringReader類型的stream。   
31.   
32. //3.   從內存取出格式化輸入    
33. try{    
34. DataInputStream   in3   =      
35. new   DataInputStream(    
36. new   ByteArrayInputStream(s2.getBytes()));    
37. while(true)    
38. System.out.println((char)in3.readByte());      
39. }    
40. catch(EOFException   e){    
41. System.out.println( "End   of   stream ");    
42. }    
43.   
44. //4.   輸出到文件    
45. try{    
46. BufferedReader   in4   =    
47. new   BufferedReader(    
48. new   StringReader(s2));    
49. PrintWriter   out1   =    
50. new   PrintWriter(    
51. new   BufferedWriter(    
52. new   FileWriter( "F:\\nepalon\\   TestIO.out ")));    
53. int   lineCount   =   1;    
54. while((s   =   in4.readLine())   !=   null)    
55. out1.println(lineCount++   +   "： "   +   s);    
56. out1.close();    
57. in4.close();    
58. }    
59. catch(EOFException   ex){    
60. System.out.println( "End   of   stream ");    
61. }    
62. // 對String對象s2讀取數據時，先把對象中的數據存入緩存中，再從緩沖中進行讀取；對TestIO.out文件進行操作時，先把格式化後的信息輸出到緩存中，再把緩存中的信息輸出到文件中。   
63.   
64. //5.   數據的存儲和恢復    
65. try{    
66. DataOutputStream   out2   =      
67. new   DataOutputStream(    
68. new   BufferedOutputStream(    
69. new   FileOutputStream( "F:\\nepalon\\   Data.txt ")));    
70. out2.writeDouble(3.1415926);    
71. out2.writeChars( "\nThas   was   pi:writeChars\n ");    
72. out2.writeBytes( "Thas   was   pi:writeByte\n ");    
73. out2.close();    
74. DataInputStream   in5   =    
75. new   DataInputStream(    
76. new   BufferedInputStream(    
77. new   FileInputStream( "F:\\nepalon\\   Data.txt ")));    
78. BufferedReader   in5br   =    
79. new   BufferedReader(    
80. new   InputStreamReader(in5));    
81. System.out.println(in5.readDouble());    
82. System.out.println(in5br.readLine());    
83. System.out.println(in5br.readLine());    
84. }    
85. catch(EOFException   e){    
86. System.out.println( "End   of   stream ");    
87. }    
88. // 對Data.txt文件進行輸出時，是先把基本類型的數據輸出屋緩存中，再把緩存中的數據輸出到文件中；對文件進行讀取操作時，先把文件中的數據讀取到緩存中，再從緩存中以基本類型的形式進行讀取。注意in5.readDouble()這一行。因為寫入第一個writeDouble()，所以為了正確顯示。也要以基本類型的形式進行讀取。    
89.   
90. //6.   通過RandomAccessFile操作文件    
91. RandomAccessFile   rf   =    
92. new   RandomAccessFile( "F:\\nepalon\\   rtest.dat ",   "rw ");    
93. for(int   i=0;   i <10;   i++)    
94. rf.writeDouble(i*1.414);    
95. rf.close();    
96.   
97. rf   =   new   RandomAccessFile( "F:\\nepalon\\   rtest.dat ",   "r ");    
98. for(int   i=0;   i <10;   i++)    
99. System.out.println( "Value   "   +   i   +   "： "   +   rf.readDouble());    
100. rf.close();    
101.   
102. rf   =   new   RandomAccessFile( "F:\\nepalon\\   rtest.dat ",   "rw ");    
103. rf.seek(5*8);    
104. rf.writeDouble(47.0001);    
105. rf.close();    
106.   
107. rf   =   new   RandomAccessFile( "F:\\nepalon\\   rtest.dat ",   "r ");    
108. for(int   i=0;   i <10;   i++)    
109. System.out.println( "Value   "   +   i   +   "： "   +   rf.readDouble());    
110. rf.close();    
111. }    
112. }   

        看了以上詳解說明，是不是對Java輸入輸出流類的概念有了更清晰的認識，對它們的使用也更得心應手了呢？