}

}

}

五、實驗指導與處理

六、分析討論

實驗教師評語成績

簽名：

日期：

第二篇：Java 實驗 文件管理與IO流

作業要求：每個題保存為一個.java文件，保存在同一工程文件夾中，文件夾的名字為E:Java你的班級+姓名，例如：E:Java信息11張三。

注意：上交的程序包含程序的執行結果，以注釋的形式附在程序后面。

實驗六文件管理與I/O流

一、實驗目的1．熟悉用文件File類創建、刪除、查看文件或目錄。

2．字節流、字符流、緩沖流、隨機流等流式文件的創建，讀寫操作。

3．用字符流和緩沖流從鍵盤接受字符串的方法。

二、實驗內容

1．先運行該程序。源文件是sy6_1.java。然后按【思考問題】分析程序。

import java.io.*;

public class sy6_1{

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

{

int x=0;

File Mypath;

Mypath=new File(“E:aaaa”);

if(!Mypath.exists())

{System.out.println(“創建新目錄”);Mypath.mkdir();}

else System.out.println(“目錄已存在”);

File Myfile1=new File(Mypath,“myfile1.txt”);

File Myfile2=new File(Mypath,“myfile2.txt”);

File Myfile3=new File(Mypath,“myfile3.txt”);

FileInputStream Fin=new FileInputStream(Myfile1);

FileOutputStream Fout=new FileOutputStream(Myfile1);

DataOutputStream Dout=new DataOutputStream(new FileOutputStream(Myfile2));

DataInputStream Din=new DataInputStream(new FileInputStream(Myfile2));

PrintWriter PWout=new PrintWriter(new FileWriter(Myfile3));

RandomAccessFile RAread=new RandomAccessFile(Myfile3,“r”);

String str;

int num1;

BufferedReader buf;//緩沖流

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

System.out.print(“請輸入一個小于255整型數:”);

while(!(str=buf.readLine()).equalsIgnoreCase(“q”))

{ System.out.print(“請輸入另一個小于255整型數，按Q結束:”);

num1=Integer.parseInt(str);

Fout.write(num1);

}Fout.close();

System.out.println(“你剛輸入的數據是：”);

while((x=Fin.read())!=-1)

{ System.out.println(x);

}Fin.close();

System.out.print(“請輸入int范圍內整型數:”);

while(!(str=buf.readLine()).equalsIgnoreCase(“q”))

{ System.out.print(“請輸入另一個整型數，按Q結束:”);

num1=Integer.parseInt(str);

Dout.writeInt(num1);

}Dout.close();

int leng=Din.available()/4;

int xxx=0;

while(xxx

{ xxx++;

x=Din.readInt();

System.out.println(x);

} Din.close();

System.out.print(“請輸入第一個字符串:”);

while((str=buf.readLine())!=null)

{ System.out.print(“請輸入另一個字符串，按Ctrl+Z結束:”);

PWout.println(str);//寫入myfile3.txt中

} PWout.close();

RAread.seek(0);

while(RAread.getFilePointer()

{System.out.println(RAread.readLine());//從myfile3.txt中一行一行讀并輸出在控制臺上

} RAread.close();

System.out.println(“完成”);

}

}

【思考問題】

① 本程序共用到哪幾種流式文件？都用于做什么？

答：基本輸入輸出流：System.in.輸入（從鍵盤）

System.out.輸出（顯示器）

字節流類：FileOutputStream 文件輸出

FileInputStream 文件輸入

DataOutputStream數據輸出

DataInputStream數據輸入

字符流類：PrintWriter輸入

緩沖文件流：BufferedReader

② 運行完程序后，請用“我的電腦”找到創建的文件，并分別打開文件看其內容，你

看到的是你輸入的數據嗎？

答：myfile1和myfile2中的數據非輸入數據，myfile3中可以看見輸入的數據。③ 將創建輸入流對象Fin放在輸出流Fout前，看發生什么？

④ 對第二種流式文件判斷文件占用字節的長度用available()方法，而此處用int

leng=Din.available()/4;為什么除以4？

2．按照第1題的內容，修改程序要求每次重新運行不覆蓋原內容，把所有其它流式文件全部改用隨機流式文件來實現，新的數據填加在文件尾，然后讀出校驗。

import java.io.*;

public class sy6_2 {

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

File Mypath;

Mypath = new File(“E:aaa”);

if(!Mypath.exists())

{System.out.println(“創建新目錄”);Mypath.mkdir();}

else System.out.println(“目錄已存在”);

File Myfile1 = new File(Mypath, “myfile1.txt”);

File Myfile2 = new File(Mypath, “myfile2.txt”);

File Myfile3 = new File(Mypath, “myfile3.txt”);

RandomAccessFile rf1 = new RandomAccessFile(Myfile1, “rw”);

RandomAccessFile rf2 = new RandomAccessFile(Myfile2, “rw”);

RandomAccessFile rf3 = new RandomAccessFile(Myfile3, “rw”);

String str;

int num1;

BufferedReader buf;//緩沖流

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

System.out.print(“請輸入一個小于255整型數:”);

rf1.seek(rf1.length());//指針移到文件尾進行寫操作

while(!(str=buf.readLine()).equalsIgnoreCase(“q”))

{ System.out.print(“請輸入另一個小于255整型數，按Q結束:”);num1=Integer.parseInt(str);

rf1.write(num1);//將整型數作為ascii碼值所對應的字符寫入myfile1.txt中}

rf1.seek(0);//指針移到文件頭進行讀操作

int x=0;

while((x=rf1.read())!=-1)

{

System.out.println(x);

} rf1.close();

System.out.print(“請輸入int范圍內整型數:”);

rf2.seek(rf2.length());

while(!(str = buf.readLine()).equalsIgnoreCase(“q”)){

System.out.print(“請輸入另一個整型數，按Q結束:”);

num1 = Integer.parseInt(str);

rf2.writeInt(num1);

}

int x1 = 0;

for(int l = 0;l

{

rf2.seek(l*4);

x1 = rf2.readInt();

System.out.println(x1);

}

rf2.close();

System.out.print(“請輸入第一個字符串:”);

rf3.seek(rf3.length());

while((str = buf.readLine())!= null){

System.out.println(“請輸入另一個字符串，按Ctrl+Z結束:”);rf3.writeUTF(str);//寫入myfile3.txt中

}

rf3.seek(0);

while(rf3.getFilePointer()< rf3.length()){

System.out.println(rf3.readUTF());//從myfile3.txt中讀出字符串并輸出在控制臺上

}

rf3.close();

System.out.println(“完成”);

}

}

三、實驗報告要求

1．回答第1題【思考問題】提出的問題。

2．寫出第二題要求的源程序。

第三篇：Java實驗五 IO流的一般使用

Java實驗五IO流的一般使用

實驗目的：掌握文件類的使用，了解一般流的基本應用。加深處理代碼的能力。實驗內容：

import java.io.*;

public class lijun43

{

public static void main(String args[])

{

File f = new File(“f:mldn.txt”);

if(f.exists())

{

System.out.println(“文件已存在。”);

}

else

{

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

}

}

};

import java.io.*;

public class lijun45

{

public static void main(String args[])

{

loop(“d:”);

}

public static void loop(String dir)

{

File f = new File(dir);

String str[] = null;

if(f.isDirectory())

{

str = f.list();

for(int i=0;i

{

loop(dir+“”+str[i]);

}

}

else

{

System.out.println(dir);

}

}

};

實驗結果：

1f:mldn.txt在f盤中出現了。

心得體會：

需要多嘗試，流主要是對文件俠的操作，比如文件俠創建，移動，刪除等，打開一個流，

第四篇：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();} } }