第一篇：08 Java當中的輸入輸出流的學習筆記 基本IO

流的分類：

輸入流(InputStream/Reader)，輸出流(OutputStream/Writer)

字節流(InputStream，OutputStream)字符流(Reader/Writer)

節點流(InputStream/Reader,OutputStream/Writer)，處理流(過濾流)BufferedIO(緩沖),DataInputStream/DataOutputStream(各種數據類型), InputStreamReader/OutputStreamWriter(轉換流)，ByteArrayInputStream/ ByteArrayOutputStream(內存數組流)PipedInputStream/ PipedOutputStream(管道流，線程間通訊)

1.或者OutputStream可以創建一個文件，但是不能創建一個文件夾。

2.InputStream（OutputStream）和Reader(Writer)的區別在于字節和字符,對于非標準ASCII

編碼（占用兩個字節的字符）字節流會出現亂碼。

3.使用bufferedIO是為了readline（）方法和write（s），s是一個字符串。而且

bufferedinPutStream有mark和reset方法。

4.InputStreamReader和OutputStreamWriter可以把字節流轉換為字符流。

InputStreamReader需要和InputStream套接。OutputStreamWriter需要和OutputStream套接。OutputStreamWriter可以寫一個字符串。還有一個典型的應用就是在于對于System.in的處理。

InputStreamReaderisr =

newInputStreamReader(System.in);

BufferedReaderbr = newBufferedReader(isr)；

System.in是一個InputStream的子類，需要把它改成InputStreamReader然后使用BufferedReader讀出每行的內容。

5.DataInputStream,DataOutputStream是用來對付原始的數據類型，比如int，long，double，float 和UTF。

6.ByteArrayInputStream和ByteArrayOutputStream在內存中創建一個字節數組。

import java.io.*;

publicclassTestDataStream {

publicstaticvoid main(String[] args){

ByteArrayOutputStreambaos =

newByteArrayOutputStream();//在內存中創建了一個內存字節數組，并對上一個管道baos DataOutputStream dos =

newDataOutputStream(baos);//使用DataOutputStream是為了使用writeDouble，writeBoolean等方法

try {

dos.writeDouble(Math.random());//在字節數組當中寫入8個字節的double類型的數字 dos.writeBoolean(true);//在字節數組中寫入一個boolean類型的true，占用1個字節

ByteArrayInputStreambais =

newByteArrayInputStream(baos.toByteArray());//bais也對到由baos對應的內存字節數組

System.out.println(bais.available());//內存數組當中有多少字節可用（也就是說被寫入了多少個字節的內容）

DataInputStream dis = newDataInputStream(bais);//使用DataInputStream是為了使用readDouble，readBoolean等方法

System.out.println(dis.readDouble());//先寫進去的東西要先讀是隊列

System.out.println(dis.readBoolean());//后寫進去的東西要后讀

dos.close();

dis.close();

} catch(IOException e){

e.printStackTrace();

}

}

}

7.PipedInputStream和PipedOutputStream是管道流，用于線程間的通信。一個線程的PipedInputStream對象必須從另一個線程的PipedOutputStream對象讀取輸入。要使用管道流，必須同時構造管道輸入流和輸出流。

8.Print流就只有輸出流，沒有輸入流。

Print流不會拋異常，而且都會自動flush。

System.setOut(ps);//修改系統輸出的位置

9.Object流和序列化問題

將對象轉換為字節流并保存起來（文件，磁盤，網絡），這種機制叫做對象序列化。并在日后還原這個對象，這種機制叫對象的反序列化。將一個對象保存到永久存儲設備上稱為持續性。

使用ObjectOutputStream和ObjectInputStream來專門用來把一個object寫入或者讀出硬盤上。（常用于游戲存盤？）其做法是把整個的object寫入磁盤或者讀出。

當一個對象被序列化時，只保存對象的非靜態成員變量，不能保存任何的成員方法和靜態的成員變量。如果一個對象的成員變量是一個對象，那么這個對象的數據成員也會被保存。

為了把一個類的對象寫到硬盤或者網絡，就必須實現serializable接口或Externalizable接口。區別是在于和Externalizable（外部化）是接口是抽象方法，必須被實現。而Serializable（序列化）是一個標示形接口，也就是說，這樣的接口是沒有方法。Java當中還有很多這樣的接口。但是我們必須實現這個接口，這個接口的意義是在于讓java編譯器知道這個該類需要實現了這個功能。要注意，如果該類沒有實現這個接口，會拋出一個NotSerializableException。

有的時候，一個可序列化的對象包含對某個不可序列化的對象的引用，那么整個序列化操作將會失敗，并且會拋出一個NotSerializableException。為了解決這個問題，可以將這個引用標記為transient，那么對象仍然可以序列化。也就是說，transient修飾的成員變量在序列化的時候，是不給予考慮的，也就是說被transient修飾的內容是不會被保存的。

Externalizable接口當中有兩個抽象方法，必須被實現.

第二篇：JAVA,IO流學習總結

篇一：java之io流學習總結 java之io流學習總結

一、什么是流？

流就是字節序列的抽象概念，能被連續讀取數據的數據源和能被連續寫入數據的接收端就是流，流機制是java及c++中的一個重要機制，通過流我們可以自由地控制文件、內存、io設備等數據的流向。而io流就是用于處理設備上的數據，如：硬盤、內存、鍵盤錄入等。io流根據處理類型的不同可分為字節流和字符流，根據流向的不同可分為輸入流和輸出流。

二、字節流和字符流的區別：字符流，因為文件編碼的不同，就有了對字符進行高效操作的字符流對象，它的原理就是基于字節流讀取字節時去查了指定的碼表。它和字節流的區別有兩點：1.在讀取數據的時候，字節流讀到一個字節就返回一個字節，字符流使用了字節流讀到一個或多個字節（一個中文對應的字節數是兩個，在utf-8碼表中是3個字節）時，先去查指定的編碼表，再將查到的字符返回；2.字節流可以處理所有類型的數據，如jpg、avi、mp3、wav等等，而字符流只能處理字符數據。所以可以根據處理的文件不同考慮使用字節流還是字符流，如果是純文本數據可以優先考慮字符流，否則使用字節流。

三、io體系，所具備的基本功能就是讀和寫： 1.字符流

|--reader（讀）|--writer（寫）reader |--inputstreamreader |--filereader：用于處理文件的字符讀取流對象 writer |--outputstreamwriter |--filewriter：用于處理文件的字符寫入流對象

其實很容易就可以看出來，io體系中的子類名后綴絕大部分是父類名稱，而前綴則是體現子類特有功能的名稱。reader中常見的方法： |--int read()讀取一個字符，并返回讀到的這個字符，讀到流的末尾則返回-1。|--int read(char[])將讀到的字符存入指定的數組中，返回的是讀到的字符個數，讀到流的末尾則返回-1。|--close()讀取字符其實用的是window系統的功能，就希望使用完畢后，進行資源的釋放。filereader除了自己的構造函數外沒有特有的方法： |--用于讀取文本文件的流對象。

|--用于關聯文本文件。在讀取流對象初始化時，必須要指定一個被讀取的文件，如果該文件不存在則會發生filenotfoundexception異常。writer中常見的方法： |--write()將一個字符寫入到流中。|--write(char[])將一個字符數組寫入到流中。|--writer(string)將一個字符寫入到流中。|--flush()刷新流，將流中的數據刷新到目的地中，流還存在。|--close()關閉資源，在關閉錢會先調用flush()，刷新流中的數據到目的地。filewriter，除了自己的構造函數外沒有特有的方法： |--該類的特點

|--用于處理文本文件 |--沒有默認的編碼表 |--有臨時緩沖

|--構造函數，在寫入流對象初始化時，必須要有一個存儲數據的目的地。|--filewriter(string filename)，該構造器是干什么用的呢？ |--調用系統資源

|--在指定位置創建一個文件，如果該文件已經存在則被覆蓋。

|--filewriter(string filename,boolean append)，這構造器的作用是當傳入的boolean類型的值為true時，會在指定文件末尾處進行數據的續寫。

清單1，將文本數據保存到文件中代碼 private static void test1(){filewriter fw=null;//初始化filewriter對象，指定文件名已經存儲路徑 fw=new filewriter(d:/test.txt);fw.write(將字符串寫入流);//將流中的數據刷新到目的地，流還在 fw.flush();fw.write(將字符串寫入流);} catch(ioexception e){ e.printstacktrace();}finally{ if(fw!=null){ try {fw.close();} catch(ioexception e1){e1.printstacktrace();}}} } 清單2，讀取一個已有文本文件，并將文本內容打印出來代碼 private static void test2(){filereader fr=null;try { //初始化filereader對象，指定文件路徑 fr=new filereader(d:/test.txt);int ch=0;while((ch=fr.read())!=-1){ //每次讀取一個字符，直到讀到末尾-1為止 system.out.println((char)ch);} catch(ioexception e){ e.printstacktrace();}finally{ if(fr!=null){ try {fr.close();} catch(ioexception e1){e1.printstacktrace();}}} } 這樣每讀到一個字符就打印出來，效率很不高，能不能按指定大小讀取完后再打印出來呢？答案是當然可以的。

清單3，讀取一個已有文本文件，讀完1kb再將其讀到的內容打印出來代碼 private static void test3(){filereader fr=null;try { //初始化filereader對象，指定文件路徑 fr=new filereader(d:/test.txt);char[] buf=new char[1024];int len=0;while((len=fr.read(buf))!=-1){ //每次讀取1kb大小的字符，直到讀到末尾-1為止

system.out.println(new string(buf,0,len));}} catch(ioexception e){篇二：java io流學習總結 java流操作有關的類或接口：

java流類圖結構：流的概念和作用

流是一組有順序的，有起點和終點的字節集合，是對數據傳輸的總稱或抽象。即數據在兩設備間的傳輸稱為流，流的本質是數據傳輸，根據數據傳輸特性將流抽象為各種類，方便更直觀的進行數據操作。io流的分類

? 根據處理數據類型的不同分為：字符流和字節流 ? 根據數據流向不同分為：輸入流和輸出流

字符流和字節流

字符流的由來： 因為數據編碼的不同，而有了對字符進行高效操作的流對象。本質其實就是基于字節流讀取時，去查了指定的碼表。字節流和字符流的區別：

? 讀寫單位不同：字節流以字節（8bit）為單位，字符流以字符為單位，根據碼表映射 字符，一次可能讀多個字節。

? 處理對象不同：字節流能處理所有類型的數據（如圖片、avi等），而字符流只能處 理字符類型的數據。

結論：只要是處理純文本數據，就優先考慮使用字符流。除此之外都使用字節流。輸入流和輸出流

對輸入流只能進行讀操作，對輸出流只能進行寫操作，程序中需要根據待傳輸數據的不同特性而使用不同的流。java io流對象

1.輸入字節流inputstreamio 中輸入字節流的繼承圖可見上圖，可以看出： 1.inputstream 是所有的輸入字節流的父類，它是一個抽象類。

2.bytearrayinputstream、stringbufferinputstream、fileinputstream 是三種基本的介質

流，它們分別從byte 數組、stringbuffer、和本地文件中讀取數據。pipedinputstream 是從與其它線程共用的管道中讀取數據，與piped 相關的知識后續單獨介紹。3.objectinputstream 和所有filterinputstream 的子類都是裝飾流（裝飾器模式的主角）。2.輸出字節流outputstream io 中輸出字節流的繼承圖可見上圖，可以看出：

1.outputstream 是所有的輸出字節流的父類，它是一個抽象類。2.bytearrayoutputstream、fileoutputstream 是兩種基本的介質流，它們分別向byte 數 組、和本地文件中寫入數據。pipedoutputstream 是向與其它線程共用的管道中寫入數據，3.objectoutputstream 和所有filteroutputstream 的子類都是裝飾流。3.字節流的輸入與輸出的對應

圖中藍色的為主要的對應部分，紅色的部分就是不對應部分。紫色的虛線部分代表這些流一般要搭配使用。從上面的圖中可以看出java io 中的字節流是極其對稱的。“存在及合理”我們看看這些字節流中不太對稱的幾個類吧！

1.linenumberinputstream 主要完成從流中讀取數據時，會得到相應的行號，至于什么 時候分行、在哪里分行是由改類主動確定的，并不是在原始中有這樣一個行號。在輸出部分沒有對應的部分，我們完全可以自己建立一個linenumberoutputstream，在最初寫入時會有一個基準的行號，以后每次遇到換行時會在下一行添加一個行號，看起來也是可以的。好像更不入流了。

2.pushbackinputstream 的功能是查看最后一個字節，不滿意就放入緩沖區。主要用在 編譯器的語法、詞法分析部分。輸出部分的bufferedoutputstream 幾乎實現相近的功能。3.stringbufferinputstream 已經被deprecated，本身就不應該出現在inputstream 部分，主要因為string 應該屬于字符流的范圍。已經被廢棄了，當然輸出部分也沒有必要需要它了！還允許它存在只是為了保持版本的向下兼容而已。

4.sequenceinputstream 可以認為是一個工具類，將兩個或者多個輸入流當成一個輸入 流依次讀取。完全可以從io 包中去除，還完全不影響io 包的結構，卻讓其更“純潔”――純潔的decorator 模式。

5.printstream 也可以認為是一個輔助工具。主要可以向其他輸出流，或者

fileinputstream 寫入數據，本身內部實現還是帶緩沖的。本質上是對其它流的綜合運用的一個工具而已。一樣可以踢出io 包！system.out 和system.out 就是printstream 的實例！4.字符輸入流reader在上面的繼承關系圖中可以看出： 1.reader 是所有的輸入字符流的父類，它是一個抽象類。

2.charreader、stringreader 是兩種基本的介質流，它們分別將char 數組、string中 讀取數據。pipedreader 是從與其它線程共用的管道中讀取數據。

3.bufferedreader 很明顯就是一個裝飾器，它和其子類負責裝飾其它reader 對象。4.filterreader 是所有自定義具體裝飾流的父類，其子類pushbackreader 對reader 對 象進行裝飾，會增加一個行號。

5.inputstreamreader 是一個連接字節流和字符流的橋梁，它將字節流轉變為字符流。filereader 可以說是一個達到此功能、常用的工具類，在其源代碼中明顯使用了將fileinputstream 轉變為reader 的方法。我們可以從這個類中得到一定的技巧。reader 中各個類的用途和使用方法基本和inputstream 中的類使用一致。后面會有reader 與inputstream 的對應關系。5.字符輸出流writer 在上面的關系圖中可以看出：

1.writer 是所有的輸出字符流的父類，它是一個抽象類。2.chararraywriter、stringwriter 是兩種基本的介質流，它們分別向char 數組、string 中寫入數據。pipedwriter 是向與其它線程共用的管道中寫入數據，3.bufferedwriter 是一個裝飾器為writer 提供緩沖功能。

4.printwriter 和printstream 極其類似，功能和使用也非常相似。5.outputstreamwriter 是outputstream 到writer 轉換的橋梁，它的子類filewriter 其 實就是一個實現此功能的具體類（具體可以研究一sourcecode）。功能和使用和outputstream 極其類似，后面會有它們的對應圖。6.字符流的輸入與輸出的對應 7.字符流與字節流轉換 轉換流的特點：

1.其是字符流和字節流之間的橋梁

2.可對讀取到的字節數據經過指定編碼轉換成字符 3.可對讀取到的字符數據經過指定編碼轉換成字節 何時使用轉換流？

1.當字節和字符之間有轉換動作時； 2.流操作的數據需要編碼或解碼時。具體的對象體現：

1.inputstreamreader:字節到字符的橋梁 2.outputstreamwriter:字符到字節的橋梁

這兩個流對象是字符體系中的成員，它們有轉換作用，本身又是字符流，所以在構造的時候需要傳入字節流對象進來。8.file類

file類是對文件系統中文件以及文件夾進行封裝的對象，可以通過對象的思想來操作文件和文件夾。file類保存文件或目錄的各種元數據信息，包括文件名、文件長度、最后修改時間、是否可讀、獲取當前文件的路徑名，判斷指定文件是否存在、獲得當前目錄中的文件列表，創建、刪除文件和目錄等方法。篇三：java io流學習總結 java流操作有關的類或接口：

java流類圖結構：流的概念和作用

流是一組有順序的，有起點和終點的字節集合，是對數據傳輸的總稱或抽象。即數據在兩設備間的傳輸稱為流，流的本質是數據傳輸，根據數據傳輸特性將流抽象為各種類，方便更直觀的進行數據操作。io流的分類

根據處理數據類型的不同分為：字符流和字節流 ? 根據數據流向不同分為：輸入流和輸出流 ? 字符流和字節流

字符流的由來： 因為數據編碼的不同，而有了對字符進行高效操作的流對象。本質其實就是基于字節流讀取時，去查了指定的碼表。字節流和字符流的區別：

讀寫單位不同：字節流以字節（8bit）為單位，字符流以字符為單位，根據碼表映射字符，一次可能讀多個字節。

? 處理對象不同：字節流能處理所有類型的數據（如圖片、avi等），而字符流只能處理字符類型的數據。? 結論：只要是處理純文本數據，就優先考慮使用字符流。除此之外都使用字節流。

輸入流和輸出流

對輸入流只能進行讀操作，對輸出流只能進行寫操作，程序中需要根據待傳輸數據的不同特性而使用不同的流。java io流對象

1.輸入字節流inputstreamio 中輸入字節流的繼承圖可見上圖，可以看出： 1.inputstream 是所有的輸入字節流的父類，它是一個抽象類。

2.bytearrayinputstream、stringbufferinputstream、fileinputstream 是三種基本的介質流，它們分別從byte 數組、stringbuffer、和本地文件中讀取數據。pipedinputstream 是從與其它線程共用的管道中讀取數據，與piped 相關的知識后續單獨介紹。3.objectinputstream 和所有filterinputstream 的子類都是裝飾流（裝飾器模式的主角）。2.輸出字節流outputstream io 中輸出字節流的繼承圖可見上圖，可以看出：

1.outputstream 是所有的輸出字節流的父類，它是一個抽象類。2.bytearrayoutputstream、fileoutputstream 是兩種基本的介質流，它們分別向byte 數組、和本地文件中寫入數據。pipedoutputstream 是向與其它線程共用的管道中寫入數據，3.objectoutputstream 和所有filteroutputstream 的子類都是裝飾流。3.字節流的輸入與輸出的對應

圖中藍色的為主要的對應部分，紅色的部分就是不對應部分。紫色的虛線部分代表這些流一般要搭配使用。從上面的圖中可以看出java io 中的字節流是極其對稱的。“存在及合理”我們看看這些字節流中不太對稱的幾個類吧！1.linenumberinputstream 主要完成從流中讀取數據時，會得到相應的行號，至于什么時候分行、在哪里分行是由改類主動確定的，并不是在原始中有這樣一個行號。在輸出部分沒有對應的部 分，我們完全可以自己建立一個linenumberoutputstream，在最初寫入時會有一個基準的行號，以后每次遇到換行時會在下一行添加一個行 號，看起來也是可以的。好像更不入流了。2.pushbackinputstream 的功能是查看最后一個字節，不滿意就放入緩沖區。主要用在編譯器的語法、詞法分析部分。輸出部分的

bufferedoutputstream 幾乎實現相近的功能。3.stringbufferinputstream 已經被deprecated，本身就不應該出現在inputstream 部分，主要因為string 應該屬于字符流的范圍。已經被廢棄了，當然輸出部分也沒有必要需要它了！還允許它存在只是為了保持版本的向下兼容而已。4.sequenceinputstream 可以認為是一個工具類，將兩個或者多個輸入流當成一個輸入流依次讀取。完全可以從io 包中去除，還完全不影響io 包的結構，卻讓其更“純潔”――純潔的decorator 模式。5.printstream 也可以認為是一個輔助工具。主要可以向其他輸出流，或者fileinputstream 寫入數據，本身內部實現還是帶緩沖的。本質上是對其它流的綜合運用的一個工具而已。一樣可以踢出io 包！system.out 和system.out 就是printstream 的實例！4.字符輸入流reader 在上面的繼承關系圖中可以看出：

1.reader 是所有的輸入字符流的父類，它是一個抽象類。

2.charreader、stringreader 是兩種基本的介質流，它們分別將char 數組、string中讀取數據。pipedreader 是從與其它線程共用的管道中讀取數據。

3.bufferedreader 很明顯就是一個裝飾器，它和其子類負責裝飾其它reader 對象。4.filterreader 是所有自定義具體裝飾流的父類，其子類pushbackreader 對reader 對象進行裝飾，會增加一個行號。

5.inputstreamreader 是一個連接字節流和字符流的橋梁，它將字節流轉變為字符流。filereader 可以說是一個達到此功能、常用的工具類，在其源代碼中明顯使用了將fileinputstream 轉變為reader 的方法。我們可以從這個類中得到一定的技巧。reader 中各個類的用途和使用方法基本和inputstream 中的類使用一致。后面會有reader 與inputstream 的對應關系。5.字符輸出流writer 在上面的關系圖中可以看出：

1.writer 是所有的輸出字符流的父類，它是一個抽象類。2.chararraywriter、stringwriter 是兩種基本的介質流，它們分別向char 數組、string 中寫入數據。pipedwriter 是向與其它線程共用的管道中寫入數據，3.bufferedwriter 是一個裝飾器為writer 提供緩沖功能。

4.printwriter 和printstream 極其類似，功能和使用也非常相似。5.outputstreamwriter 是outputstream 到writer 轉換的橋梁，它的子類filewriter 其實就是一個實現此功能的具體類（具體可以研究一 sourcecode）。功能和使用和outputstream 極其類似，后面會有它們的對應圖。

第三篇：Java之IO流學習總結

Java之IO流學習總結

一、什么是流？

流就是字節序列的抽象概念，能被連續讀取數據的數據源和能被連續寫入數據的接收端就是流，流機制是Java及C++中的一個重要機制，通過流我們可以自由地控制文件、內存、IO設備等數據的流向。而IO流就是用于處理設備上的數據，如：硬盤、內存、鍵盤錄入等。IO流根據處理類型的不同可分為字節流和字符流，根據流向的不同可分為輸入流和輸出流。

字符流，因為文件編碼的不同，就有了對字符進行高效操作的字符流對象，它的原理就是基于字節流讀取字節時去查了指定的碼表。它和字節流的區別有兩點：1.在讀取數據的時候，字節流讀到一個字節就返回一個字節，字符流使用了字節流讀到一個或多個字節（一個中文對應的字節數是兩個，在UTF-8碼表中是3個字節）時，先去查指定的編碼表，再將查到的字符返回；2.字節流可以處理所有類型的數據，如jpg、avi、mp3、wav等等，而字符流只能處理字符數據。所以可以根據處理的文件不同考慮使用字節流還是字符流，如果是純文本數據可以優先考慮字符流，否則使用字節流。

三、IO體系，所具備的基本功能就是讀和寫： 1.字符流

|--Reader（讀）|--Writer（寫）Reader

|--InputStreamReader

|--FileReader：用于處理文件的字符讀取流對象 Writer

|--OutputStreamWriter

|--FileWriter：用于處理文件的字符寫入流對象

其實很容易就可以看出來，IO體系中的子類名后綴絕大部分是父類名稱，而前綴則是體現子類特有功能的名稱。Reader中常見的方法： |--int read()

讀取一個字符，并返回讀到的這個字符，讀到流的末尾則返回-1。|--int read(char[])

將讀到的字符存入指定的數組中，返回的是讀到的字符個數，讀到流的末尾則返回-1。|--close()

讀取字符其實用的是window系統的功能，就希望使用完畢后，進行資源的釋放。FileReader除了自己的構造函數外沒有特有的方法： |--用于讀取文本文件的流對象。|--用于關聯文本文件。

|--構造函數FileReader(String fileName)在讀取流對象初始化時，必須要指定一個被讀取的文件，如果該文件不存在則會發生FileNotFoundException異常。Writer中常見的方法： |--write()

將一個字符寫入到流中。|--write(char[])

將一個字符數組寫入到流中。|--writer(String)將一個字符寫入到流中。|--flush()

刷新流，將流中的數據刷新到目的地中，流還存在。|--close()

關閉資源，在關閉錢會先調用flush()，刷新流中的數據到目的地。

FileWriter，除了自己的構造函數外沒有特有的方法：

|--該類的特點 |--用于處理文本文件 |--沒有默認的編碼表 |--有臨時緩沖

|--構造函數，在寫入流對象初始化時，必須要有一個存儲數據的目的地。|--FileWriter(String fileName)，該構造器是干什么用的呢？ |--調用系統資源

|--在指定位置創建一個文件，如果該文件已經存在則被覆蓋。

|--FileWriter(String filename,Boolean append)，這構造器的作用是當傳入的boolean類型的值為true時，會在指定文件末尾處進行數據的續寫。

清單1，將文本數據保存到文件中代碼 private static void test1(){ FileWriter fw=null;try { //初始化FileWriter對象，指定文件名已經存儲路徑 fw=new FileWriter(“D:/test.txt”);fw.write(“將字符串寫入流”);//將流中的數據刷新到目的地，流還在 fw.flush();fw.write(“將字符串寫入流”);} catch(IOException e){ e.printStackTrace();}finally{ if(fw!=null){ try { fw.close();} catch(IOException e1){ e1.printStackTrace();} } } }

清單2，讀取一個已有文本文件，并將文本內容打印出來代碼 private static void test2(){ FileReader fr=null;try { //初始化FileReader對象，指定文件路徑 fr=new FileReader(“D:/test.txt”);int ch=0;while((ch=fr.read())!=-1){ //每次讀取一個字符，直到讀到末尾-1為止 System.out.println((char)ch);} } catch(IOException e){ e.printStackTrace();}finally{ if(fr!=null){ try { fr.close();} catch(IOException e1){ e1.printStackTrace();} } } }

這樣每讀到一個字符就打印出來，效率很不高，能不能按指定大小讀取完后再打印出來呢？答案是當然可以的。

清單3，讀取一個已有文本文件，讀完1kb再將其讀到的內容打印出來代碼 private static void test3(){ FileReader fr=null;try { //初始化FileReader對象，指定文件路徑 fr=new FileReader(“D:/test.txt”);char[] buf=new char[1024];int len=0;while((len=fr.read(buf))!=-1){ //每次讀取1kb大小的字符，直到讀到末尾-1為止 System.out.println(new String(buf,0,len));} } catch(IOException e){ e.printStackTrace();}finally{ if(fr!=null){ try { fr.close();} catch(IOException e1){ e1.printStackTrace();} } } }

字符流的緩沖區：

|--緩沖區的出現提高了對流的操作效率。原理：其實就是將數組進行封裝。|--對應的對象 |--BufferedWriter

特有方法newLine()，跨平臺的換行符。|--BufferedReader

特有方法readLine()，一次讀一行，到行標記時，將行標記之前的字符數據作為字符串返回，讀到末尾返回null。

|--說明在使用緩沖區對象時，要明確，緩沖的存在是為了增強流的功能而存在，所以在建立緩沖區對象時，要先有流對象存在。其實緩沖區內部就是在使用流對象的方法，只不過加入了數組對數據進行了臨時存儲，為了提高操作數據的效率。

|--代碼上的體現 |--寫入緩沖區對象

根據前面所說的建立緩沖區時要先有流對象，并將其作為參數傳遞給緩沖區的構造函數 BufferedWriter bufw=new BufferedWriter(new FileWriter(“test.txt”));bufw.write(“將數據寫入緩沖區”);

bufw.flush();//將緩沖區的數據刷新到目的地 bufw.close();//其實關閉的是被包裝在內部的流對象 |--讀取緩沖區對象

BufferedReader bufr=new BufferedReader(new FileReader(“test.txt”));String line=null;

while((line=bufr.readLine())!=null){ //每次讀取一行，取出的數據不包含回車符 system.out.println(line);}

bufr.close();

清單4，使用緩沖區對文本文件進行拷貝代碼 private static void test4(){ BufferedReader bufr=null;BufferedWriter bufw=null;try {

bufr=new BufferedReader(new FileReader(“D:/a.txt”));bufw=new BufferedWriter(new FileWriter(“D:/b.txt”));String line=null;while((line=bufr.readLine())!=null){ bufw.write(line);//每次將一行寫入緩沖區 bufw.flush();//刷新到目的地 } } catch(IOException e){ e.printStackTrace();}finally{ try { if(bufw!=null){ bufw.close();} if(bufr!=null){ bufr.close();} } catch(IOException e1){ e1.printStackTrace();} } }

仔細看可以發現，程序里面的FileReader對象和FileWriter對象直接new出來且沒有調用close()，因為緩沖對象調用了這兩個方法，前面說了，緩沖對象調用的flush()和close()其實就是關閉被包裝在其內部的流對象。關閉流的先后順序也要注意，如果流之間有依賴關系，則被依賴的流要后關閉。readLine()方法原理：其實緩沖區中的該方法，用的還是與緩沖區關聯的流對象的read方法，只不過，每一次讀到一個字符先不進行具體操作，先進行臨時存儲，當讀到回車標記時，將臨時容器中存儲的數據一次性返回。我們可以根據這個原理來自己編寫一個緩沖區對象。

清單5，編寫一個自己的bufferedreader代碼

public class MyBufferedReader { private Reader reader;public MyBufferedReader(Reader reader){ this.reader=reader;}

public String readLine()throws IOException{ StringBuilder sb=new StringBuilder();int ch=0;while((ch=reader.read())!=-1){ if(ch=='r'){//空格則繼續 continue;}else if(ch=='n'){//每次返回一行 return sb.toString();}else{ sb.append((char)ch);} } return sb.toString();}

public void close()throws IOException{ //緩沖對象的關閉方法其實就是調用流本身的close()reader.close();} }

測試時把清單4的BufferedReader對象替換成MyBufferedReader對象即可。

清單6，測試mybufferedreader代碼 private static void test4(){ MyBufferedReader bufr=null;BufferedWriter bufw=null;try {

bufr=new MyBufferedReader(new FileReader(“D:/a.txt”));bufw=new BufferedWriter(new FileWriter(“D:/b.txt”));String line=null;while((line=bufr.readLine())!=null){ bufw.write(line);//每次將一行寫入緩沖區 bufw.flush();//刷新到目的地 } } catch(IOException e){ e.printStackTrace();}finally{ try { if(bufw!=null){ bufw.close();} if(bufr!=null){ bufr.close();} } catch(IOException e1){ e1.printStackTrace();} } }

其實我們自己寫的這個緩存對象就是對Reader對象進行了功能的增強，Reader對象每次只能返回一個字符，而增強了功能之后該類就可以每次返回一行字符，也就是設計模式中所說的裝飾模式。

2.字節流

|--InputStream（讀）|--OutputStream（寫）

由于字節是二進制數據，所以字節流可以操作任何類型的數據，值得注意的是字符流使用的是字符數組char[]而字節流使用的是字節數組byte[]。下面來看一個字節流讀寫文件的簡單例子。

清單7，使用字節流讀寫文本文件代碼 private static void test5(){ FileOutputStream fos=null;try{ fos=new FileOutputStream(“D:/test.txt”);fos.write(0010);//寫入二進制數據 fos.flush();}catch(IOException e){ }finally{ try{ fos.close();}catch(IOException ex){ } } FileInputStream fis=null;try{ fis=new FileInputStream(“D:/test.txt”);//fis.available()是獲取關聯文件的字節數，即test.txt的字節數 //這樣創建的數組大小就和文件大小剛好相等

//這樣做的缺點就是文件過大時，可能超出jvm的內存空間，從而造成內存溢出 byte[] buf=new byte[fis.available()];fis.read(buf);System.out.println(new String(buf));}catch(IOException e){ }finally{ try{ fos.close();}catch(IOException ex){ } } }

清單8，使用緩沖區對一張圖片進行復制代碼 private static void test6(){ BufferedOutputStream bos=null;BufferedInputStream bis=null;try{ //前面已經說過了，緩沖對象是根據具體的流對象創建的，所以必須要有流對象 bis=new BufferedInputStream(new FileInputStream(“E:imageswo1.jpg”));//寫入目標地址

bos=new BufferedOutputStream(new FileOutputStream(“E: est.jpg”));byte[] buf=new byte[1024];while((bis.read(buf))!=-1){ bos.write(buf);} bos.flush();}catch(IOException e){ e.toString();}finally{ try{ if(bos!=null){ bos.close();} if(bis!=null){ bis.close();} }catch(IOException ex){ ex.toString();} } }

3.轉換流

特點

|--是字節流和字符流之間的橋梁

|--該流對象可以對讀取到的字節數據進行指定編碼表的編碼轉換

何時使用

|--當字節和字符之間有轉換動作時 |--流操作的數據需要進行編碼表的指定時

具體對象體現

|--InputStreamReader：字節到字符的橋梁 |--OutputStreamWriter：字符到字節的橋梁

說明

這兩個流對象是字符流體系中的成員，它們有轉換的作用，而本身又是字符流，所以在new的時候需要傳入字節流對象。

構造函數

|--InputStreamReader(InputStream)

通過該構造函數初始化，使用的是系統默認的編碼表GBK。|--InputStreamReader(InputStream,String charset)

通過該構造函數初始化，可以通過charset參數指定編碼。|--OutputStreamWriter(OutputStream)

使用的是系統默認的編碼表GBK。

|--OutputStreamWriter(OutputSream,String charset)

通過該構造函數初始化，可以通過參數charset指定編碼。

操作文件的字符流對象是轉換流的子類

|--Reader

|--InputStreamReader（轉換流）|--FileReader（文件字符流）

|--Writer

|--OutputStreamWriter（轉換流）|--FileWriter（文件字符流）

說明

轉換流中的read方法，已經融入了編碼表，在底層調用字節流的read方法時將獲取的一個或者多個字節數據進行臨時存儲，并去查指定的編碼表，如果編碼沒有指定，則使用默認編碼表。

既然轉換流已經完成了編碼轉換的動作，對于直接操作的文本文件的FileReader而言，就不用再重新定義了，只要繼承該轉換流，獲取其方法，就可以直接操作文本文件中的字符數據了。

注意

在使用FileReader操作文本數據時，該對象使用的是默認的編碼表，如果要使用指定的編碼表，必須使用轉換流。

代碼體現

FileReader fr=new FileReader(“test.txt”);InputStreamReader isr=new InputStreamReader(new FileInputStreamReader(“test.txt”));

這兩句代碼意義相同，操作test.txt中的數據都是使用了系統默認的編碼GBK。因為我們系統默認使用的編碼表是GBK，如果test.txt中的數據是通過UTF-8形式編碼的，那么在讀取的時候就需要指定編碼表，因此轉換流必須使用InputStreamReader isr=newInputStreamReader(new FileInputStream(“a.txt”),”UTF-8”);

四、流操作的基本規律

|--明確數據源和數據匯（數據目的）

其實是為了明確是輸入流還是輸出流

|--明確操作的數據是否是純文本數據

|--說明

數據源

鍵盤System.in、硬盤、File開頭的流對象、內存（數組）。

數據匯

控制臺System.out、硬盤、File開頭的流對象、內存（數組）。

|--需求

將鍵盤錄入的數據存儲到一個文件中和打印到控制臺

|--數據源System.in

既然是源，使用的就是輸入流，可用的體系有InputStream、Reader。因為鍵盤錄入進來的一定是純文本數據，所以可以使用專門操作字符數據的Reader。而System.in對應的流是字節讀取流，所以要將其進行轉換，將字節轉換成字符即可，所以要使用Reader體系中的InputStreamReader，如果要提高效率，就使用BufferedReader，代碼如：

BufferedReader bur=new BufferedReader(newInputStreamReader(Sysem.in));

|--數據匯：一個文件、硬盤

數據匯一定是輸出流，可以用的體系有OutputStream、Writer。往文件中存儲的都是文本數據，那么可以使用字符流較為方便Writer。因為操作的是一個文件，所以使用Writer中的FileWriter，同理，要提高效率就要使用BufferedWriter。

代碼如：BufferedWriter bufr=new BufferedWriter(new

FileWriter(“test.txt”));

清單9，將鍵盤錄入的數據存儲到一個文件中和打印到控制臺代碼 private static void test7(){ BufferedReader bur=null;OutputStreamWriter osw=null;BufferedWriter bw=null;try{ //數據源

bur=new BufferedReader(new InputStreamReader(System.in));//數據匯

osw=new OutputStreamWriter(System.out);//數據匯，因為數據源用的是系統默認編碼，所以這里可以直接使用FileWriter //否則必須使用OutputStreamWriter轉換流

bw=new BufferedWriter(new FileWriter(“D: est_target.txt”));String line=null;while((line=bur.readLine())!=null){ osw.write(line);osw.flush();//刷新到控制臺 bw.write(line);bw.flush();//刷新到文本文件 } }catch(IOException e){ e.toString();}finally{ try{ if(osw!=null){ osw.close();} if(bur!=null){ bur.close();} if(bw!=null){ bw.close();} }catch(IOException ex){ ex.toString();} } }

清單9是按照默認編碼表寫入文本文件的，那么如何按照指定編碼表寫入文件呢？其實也很簡單，將清單9的代碼稍微改一下就可以了。

清單10代碼

private static void test8(){ BufferedReader bur=null;BufferedWriter bw=null;try{ //數據源

bur=new BufferedReader(new InputStreamReader(System.in));//數據匯，按照指定編碼格式存儲到文本文件

bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“D: est_target.txt”),“UTF-8”));String line=null;while((line=bur.readLine())!=null){ bw.write(line);bw.flush();//刷新到文本文件 } }catch(IOException e){ e.toString();}finally{ try{ if(bur!=null){ bur.close();} if(bw!=null){ bw.close();} }catch(IOException ex){ ex.toString();} } }

既然寫入文件時指定了編碼，那么在讀取的時候就必須指定該編碼才能正確顯示。

清單11,讀取指定編碼表的文件代碼 private static void test9(){ BufferedReader bur = null;try { // 注意，這里讀取的是清單8寫入的文件，// 清單10用UTF-8編碼格式寫入，// 所以在構造InputStreamReader時必須指定UTF-8編碼 bur = new BufferedReader(new InputStreamReader(new FileInputStream(“D: est_target.txt”), “UTF-8”));String line = null;while((line = bur.readLine())!= null){ System.out.println(line);} } catch(IOException e){ e.toString();} finally { try { if(bur!= null){ bur.close();} } catch(IOException ex){ ex.toString();} } }

寫入和讀取都做了，現在還差個復制操作，其實復制文件也很簡單，先讀取文件，再將讀取到的數據寫入文件，不同的是，在讀取和寫入時我們可以指定編碼表。

清單12代碼

private static void test11(){ BufferedReader bur = null;BufferedWriter buw = null;try { bur = new BufferedReader(new InputStreamReader(new FileInputStream(“D: est_target.txt”), “UTF-8”));buw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“D: est_target1.txt”),“UTF-8”));String line = null;while((line = bur.readLine())!= null){ buw.write(line);buw.flush();// 刷新到文本文件 } } catch(IOException e){ e.toString();} finally { try { if(buw!= null){ buw.close();} if(bur!= null){ bur.close();} } catch(IOException ex){ ex.toString();} } }

第四篇：java 文件與輸入輸出流

實驗2文件與輸入輸出流(1)

一、實驗目的? 能夠使用File類表示文件或目錄，獲取相關信息，并進行文件操作； ? 能夠利用InputStream和OutputStream的子類進行字節讀、寫操作，明白其優點及不足；

? 能夠用FileInputStream和FileOutputStream進行文件讀寫的操作； ? 理解“逐層包裝”思想，能夠利用“數據流”(DataInputStream和DataOutputStream)包裝字節流，方便各類數據的讀寫；

? 能夠利用“緩沖字節流”(BufferedInputStream和BufferedOutputStream)包裝字節流，加快數據的讀寫速度；

? 熟知System.in和System.out是PrintStream的實例。

二、實驗步驟

在Eclipse環境中導入項目“code(lab_2)”,然后按要求完成各小題：

1．打開FileTest.java文件，請按下列要求進行操作：

(1)按要求填充程序所缺代碼；

(2)程序的運行需要用到一個命令行參數，請分別用一個文件、目錄作參數來運行程序，看一看結果有什么不同。

(在Eclipse中設置命令行參數方法：Run/Open Run Dialog ?/(x)=Arguments設置)

2．在上一題的基礎上，修改程序，使之具備輸出指定目錄下所有子目錄中文件絕對路徑名、大小的功能，如下所示：

子目錄：C:jdk1.6.0sample

子目錄：C:jdk1.6.0samplewebservices

子目錄：C:jdk1.6.0samplewebservicesEbayServer

文件: C:jdk1.6.0samplewebservicesEbayServerbuild.properties,大小: 512 字節 文件: C:jdk1.6.0samplewebservicesEbayServerbuild.xml,大小: 3168 字節1

……

提示：參考課件 FileSpace.java內容，通過一個以“路徑名”為參數的靜態方法來實現：該方法先判斷“路徑名”是一個文件，還是一個目錄？如果是文件，則輸出其絕對路徑和大小；若為一個目錄，則先顯示目錄絕對路徑，再列出該目錄下的所有子目錄和文件，通過循環和遞歸方法來執行后續處理。

3．文件FileOutputStreamTest.java的功能是：利用FileOutputStream類向myfile.txt文件寫入'0'~'9'和“用字節流寫入文件內容”，請填充程序所缺代碼，并運行程序。然后打開myfile.txt文件，查看其內容是否與要求相符？

4．文件FileInputStreamTest1.java的功能是：利用FileInputStream類以“逐字節”方式讀取myfile.txt文件內容，并輸出。請填充程序所缺代碼，并運行程序。問題：為什么程序輸出的內容為亂碼？

5．在FileInputStreamTest1.java的基礎上，編寫程序FileInputStreamTest2.java，利用FileInputStream類以“字節數組”方式讀取myfile.txt文件內容，能正確輸出，解決亂碼問題。

思考題：亂碼問題是怎樣解決的？

6．若要將信息“Java開發典型模塊大全”(書名)、“明日科技”(作者)、79.5(價格)等信息以UTF、double類型保存到文件books.txt中，請用“數據流”類編程實現。

第五篇：JAVA(IO流方法)

package Stream;

import java.io.*;

public class Io {

public void test1()throws Exception{

File file=new File(“E:/txt.txt”);

if(file.exists()){

System.out.println(“是否是文件：”+file.isFile());

System.out.println(“文件名是：”+file.getName());

System.out.println(“路徑是：”+file.getPath());

System.out.println(“絕對路徑是：”+file.getAbsolutePath());System.out.println(“上級目錄是：”+file.getParent());System.out.println(“文件大小是：”+file.length()+“字節”);}

else {

file.createNewFile();

}

}

public void test2()throws Exception{//以字節流方式讀取

File file=new File(“E:/txt1.txt”);

FileInputStream fi=new FileInputStream(file);

byte[] content= new byte[fi.available()];

/*for(int i=0;i

content[i]=(byte)fi.read();

}//讀取長度后，將其轉換成字符型

*///第一種方式

fi.read(content);//第二種方式

String str=new String(content);

System.out.println(str.trim());

}

public void test3()throws Exception{//以字節流方式寫入數據

File file=new File(“E:/txt1.txt”);

FileOutputStream fo=new FileOutputStream(file);

byte[]content=new String(“你是一個”).getBytes();

fo.write(content);

content=new String(“呵呵”).getBytes();

fo.write(content);

fo.close();

}

public void test4()throws Exception{//用的緩沖方式文本讀取

FileReader file=new FileReader(“E:/txt1.txt”);

BufferedReader br=new BufferedReader(file);

StringBuffer str=new StringBuffer();

String sw=br.readLine();

if(sw!=null){

str.append(sw+“ n”);

}

System.out.println(str);

}

public void test5()throws Exception{//用緩沖的方式寫入數據然后再讀入數據

FileWriter file=new FileWriter(“E:/txt1.txt”);

BufferedWriter bw=new BufferedWriter(file);

for(int i=1;i<=10;i++){

bw.write(“這是第”+i+“行”);

bw.newLine();

}

bw.close();//寫放數據

FileReader file1=new FileReader(“E:/txt1.txt”);

BufferedReader br=new BufferedReader(file1);

StringBuffer str=new StringBuffer();

String sw=br.readLine();

if(sw!=null){

str.append(sw+“ n”);

}

System.out.println(str);

}

public void test6(){//刪除文件

File file=new File(“E:/text.txt”);

if(file.exists()){

System.out.println(“開始刪除文件 :”+file.getPath());if(file.delete()){

System.out.println(“文件刪除成功”);

}

else {

System.out.println(“文件刪除失敗”);

}

}

else {

System.out.println(“該文件不存在”);

}

}

public void test7()throws Exception{//創建 一個文件夾---創建一個目錄或路徑

File file=new File(“E:/txt1.txt”);

if(file.exists()==false){

file.createNewFile();

}

}

public void test8()throws Exception {//* 將txt.txt復制文件到txt12.txt去;以字節流的的形式復制

File file=new File(“E:/txt.txt”);

FileInputStream fi=new FileInputStream(file);

byte[] content= new byte[fi.available()];

fi.read(content);

fi.read(content, 0, content.length);

String str=new String(content);

System.out.println(str);

File file1=new File(“E:/txt12.txt”);

if(file.exists()==false){

file.createNewFile();

}//如果不存在該文件則創建一件文件 再行進復制

FileOutputStream fo=new FileOutputStream(file1,true);fo.write(content);

fo.flush();

fo.close();

fi.close();//關閉流

}

public void test9()throws Exception {//另和種方式復制文件--從緩沖的形式復制

FileReader file=new FileReader(“E:/txt.txt”);

BufferedReader br=new BufferedReader(file);

String str=br.readLine();

//從文件 里面讀取出來

FileWriter file1=new FileWriter(“E:/txt1.txt”);

BufferedWriter bw=new BufferedWriter(file1);

while(str!=null){

bw.write(str);

bw.newLine();

str = br.readLine();

}

bw.flush();

bw.close();

br.close();

}

public void test10()throws Exception{

File file=new File(“E:/txt.txt”);

InputStream is = new FileInputStream(file);

byte[] array = new byte[3];

int hasRead = 0;

File file1=new File(“E:/txt1.txt”);

OutputStream os = new FileOutputStream(file1);

while((hasRead=is.read(array, 0, array.length))!=-1)

{

System.out.println(“讀取了”+hasRead+“個字節”);

for(int i=0;i

{

System.out.println(“第”+(i+1)+“個:”+array[i]);

}

/**每次從數組array里寫入字節到文件 讀多少寫多少*/

os.write(array, 0, hasRead);

}

os.flush();

os.close();

is.close();

}

public static void main(String args[])throws Exception{

Io t=new Io();

t.test9();

}

}