Java IO流詳盡解析(轉自 http://www.2cto.com/kf/201312/262036.html)

時間 2019-12-12

標籤 java 詳盡解析 http www.2cto.com www cto com 262036.html html 欄目 Java 简体版

原文原文鏈接

流的概念和做用

學習Java IO，不得不提到的就是JavaIO流。html

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

IO流的分類

根據處理數據類型的不一樣分爲：字符流和字節流linux

根據數據流向不一樣分爲：輸入流和輸出流shell

字符流和字節流

字符流的由來：由於數據編碼的不一樣，而有了對字符進行高效操做的流對象。本質其實就是基於字節流讀取時，去查了指定的碼錶。字節流和字符流的區別：windows

（1）讀寫單位不一樣：字節流以字節（8bit）爲單位，字符流以字符爲單位，根據碼錶映射字符，一次可能讀多個字節。數組

（2）處理對象不一樣：字節流能處理全部類型的數據（如圖片、avi等），而字符流只能處理字符類型的數據。多線程

（3）字節流在操做的時候自己是不會用到緩衝區的，是文件自己的直接操做的；而字符流在操做的時候下後是會用到緩衝區的，是經過緩衝區來操做文件，咱們將在下面驗證這一點。dom

結論：優先選用字節流。首先由於硬盤上的全部文件都是以字節的形式進行傳輸或者保存的，包括圖片等內容。可是字符只是在內存中才會造成的，因此在開發中，字節流使用普遍。ssh

輸入流和輸出流

對輸入流只能進行讀操做，對輸出流只能進行寫操做，程序中須要根據待傳輸數據的不一樣特性而使用不一樣的流。ide

Java流操做有關的類或接口：

圖片參考：

http://blog.csdn.net/ilibaba/article/details/3955799

Java流類圖結構：

圖片參考:

http://blog.csdn.net/ilibaba/article/details/3955799

Java IO流對象

1. 輸入字節流InputStream

定義和結構說明：

從輸入字節流的繼承圖能夠看出：

InputStream 是全部的輸入字節流的父類，它是一個抽象類。

ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三種基本的介質流，它們分別從Byte 數組、StringBuffer、和本地文件中讀取數據。PipedInputStream 是從與其它線程共用的管道中讀取數據，與Piped 相關的知識後續單獨介紹。

ObjectInputStream 和全部FilterInputStream的子類都是裝飾流（裝飾器模式的主角）。意思是FileInputStream類能夠經過一個String路徑名建立一個對象，FileInputStream(String name)。而DataInputStream必須裝飾一個類才能返回一個對象，DataInputStream(InputStream in)。以下圖示：

實例操做演示：

【案例】讀取文件內容

12345678910111213141516/*** 字節流* 讀文件內容* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);InputStream in=newFileInputStream(f);byte[] b=newbyte[1024];in.read(b);in.close();System.out.println(newString(b));}}

注意：該示例中因爲b字節數組長度爲1024，若是文件較小，則會有大量填充空格。咱們能夠利用in.read(b);的返回值來設計程序，以下案例：

【案例】讀取文件內容

1234567891011121314151617/*** 字節流* 讀文件內容* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);InputStream in=newFileInputStream(f);byte[] b=newbyte[1024];intlen=in.read(b);in.close();System.out.println("讀入長度爲："+len);System.out.println(newString(b,0,len));}}

注意：觀察上面的例子能夠看出，咱們預先申請了一個指定大小的空間，可是有時候這個空間可能過小，有時候可能太大，咱們須要準確的大小，這樣節省空間，那麼咱們能夠這樣作：

【案例】讀取文件內容

1234567891011121314151617/*** 字節流* 讀文件內容,節省空間* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);InputStream in=newFileInputStream(f);byte[] b=newbyte[(int)f.length()];in.read(b);System.out.println("文件長度爲："+f.length());in.close();System.out.println(newString(b));}}

【案例】逐字節讀

123456789101112131415161718/*** 字節流* 讀文件內容,節省空間* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);InputStream in=newFileInputStream(f);byte[] b=newbyte[(int)f.length()];for(inti = 0; i < b.length; i++) {b[i]=(byte)in.read();}in.close();System.out.println(newString(b));}}

注意：上面的幾個例子都是在知道文件的內容多大，而後才展開的，有時候咱們不知道文件有多大，這種狀況下，咱們須要判斷是否獨到文件的末尾。

【案例】字節流讀取文件

1234567891011121314151617181920/*** 字節流*讀文件* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);InputStream in=newFileInputStream(f);byte[] b=newbyte[1024];intcount =0;inttemp=0;while((temp=in.read())!=(-1)){b[count++]=(byte)temp;}in.close();System.out.println(newString(b));}}

注意：當讀到文件末尾的時候會返回-1.正常狀況下是不會返回-1的。

【案例】DataInputStream類

123456789101112131415161718importjava.io.DataInputStream;importjava.io.File;importjava.io.FileInputStream;importjava.io.IOException;publicclassDataOutputStreamDemo{publicstaticvoidmain(String[] args) throwsIOException{File file = newFile("d:"+ File.separator +"hello.txt");DataInputStream input = newDataInputStream(newFileInputStream(file));char[] ch = newchar[10];intcount = 0;chartemp;while((temp = input.readChar()) != 'C'){ch[count++] = temp;}System.out.println(ch);}}

【案例】PushBackInputStream回退流操做

1234567891011121314151617181920212223242526importjava.io.ByteArrayInputStream;importjava.io.IOException;importjava.io.PushbackInputStream;/*** 回退流操做* */publicclassPushBackInputStreamDemo{publicstaticvoidmain(String[] args) throwsIOException{String str = "hello,rollenholt";PushbackInputStream push = null;ByteArrayInputStream bat = null;bat = newByteArrayInputStream(str.getBytes());push = newPushbackInputStream(bat);inttemp = 0;while((temp = push.read()) != -1){if(temp == ','){push.unread(temp);temp = push.read();System.out.print("(回退"+(char) temp + ") ");}else{System.out.print((char) temp);}}}}

2. 輸出字節流OutputStream

定義和結構說明：

IO 中輸出字節流的繼承圖可見上圖，能夠看出：

OutputStream 是全部的輸出字節流的父類，它是一個抽象類。

ByteArrayOutputStream、FileOutputStream是兩種基本的介質流，它們分別向Byte 數組、和本地文件中寫入數據。PipedOutputStream 是向與其它線程共用的管道中寫入數據，

ObjectOutputStream 和全部FilterOutputStream的子類都是裝飾流。具體例子跟InputStream是對應的。

實例操做演示：

【案例】向文件中寫入字符串

12345678910111213141516/*** 字節流* 向文件中寫入字符串* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);OutputStream out =newFileOutputStream(f);String str="Hello World";byte[] b=str.getBytes();out.write(b);out.close();}}

你也能夠一個字節一個字節的寫入文件：

【案例】逐字節寫入文件

123456789101112131415161718/*** 字節流* 向文件中一個字節一個字節的寫入字符串* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);OutputStream out =newFileOutputStream(f);String str="Hello World！！";byte[] b=str.getBytes();for(inti = 0; i < b.length; i++) {out.write(b[i]);}out.close();}}

【案例】向文件中追加新內容

12345678910111213141516171819/*** 字節流* 向文件中追加新內容：* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);OutputStream out =newFileOutputStream(f,true);//true表示追加模式，不然爲覆蓋String str="Rollen";//String str="\r\nRollen"; 能夠換行byte[] b=str.getBytes();for(inti = 0; i < b.length; i++) {out.write(b[i]);}out.close();}}

【案例】複製文件

1234567891011121314151617181920212223242526272829/*** 文件的複製* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {if(args.length!=2){System.out.println("命令行參數輸入有誤，請檢查");System.exit(1);}File file1=newFile(args[0]);File file2=newFile(args[1]);if(!file1.exists()){System.out.println("被複制的文件不存在");System.exit(1);}InputStream input=newFileInputStream(file1);OutputStream output=newFileOutputStream(file2);if((input!=null)&&(output!=null)){inttemp=0;while((temp=input.read())!=(-1)){output.write(temp);}}input.close();output.close();}}

【案例】使用內存操做流將一個大寫字母轉化爲小寫字母

1234567891011121314151617181920/*** 使用內存操做流將一個大寫字母轉化爲小寫字母* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String str="ROLLENHOLT";ByteArrayInputStream input=newByteArrayInputStream(str.getBytes());ByteArrayOutputStream output=newByteArrayOutputStream();inttemp=0;while((temp=input.read())!=-1){charch=(char)temp;output.write(Character.toLowerCase(ch));}String outStr=output.toString();input.close();output.close();System.out.println(outStr);}}

【案例】驗證管道流：進程間通訊

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273/*** 驗證管道流* */importjava.io.*;/*** 消息發送類* */classSend implementsRunnable{privatePipedOutputStream out=null;publicSend() {out=newPipedOutputStream();}publicPipedOutputStream getOut(){returnthis.out;}publicvoidrun(){String message="hello , Rollen";try{out.write(message.getBytes());}catch(Exception e) {e.printStackTrace();}try{out.close();}catch(Exception e) {e.printStackTrace();}}}/*** 接受消息類* */classRecive implementsRunnable{privatePipedInputStream input=null;publicRecive(){this.input=newPipedInputStream();}publicPipedInputStream getInput(){returnthis.input;}publicvoidrun(){byte[] b=newbyte[1000];intlen=0;try{len=this.input.read(b);}catch(Exception e) {e.printStackTrace();}try{input.close();}catch(Exception e) {e.printStackTrace();}System.out.println("接受的內容爲 "+(newString(b,0,len)));}}/*** 測試類* */classhello{publicstaticvoidmain(String[] args) throwsIOException {Send send=newSend();Recive recive=newRecive();try{//管道鏈接send.getOut().connect(recive.getInput());}catch(Exception e) {e.printStackTrace();}newThread(send).start();newThread(recive).start();}}

【案例】DataOutputStream類示例

12345678910111213141516importjava.io.DataOutputStream;importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;publicclassDataOutputStreamDemo{publicstaticvoidmain(String[] args) throwsIOException{File file = newFile("d:"+ File.separator +"hello.txt");char[] ch = { 'A', 'B', 'C'};DataOutputStream out = null;out = newDataOutputStream(newFileOutputStream(file));for(chartemp : ch){out.writeChar(temp);}out.close();}}

【案例】ZipOutputStream類

先看一下ZipOutputStream類的繼承關係

java.lang.Object

java.io.OutputStream

java.io.FilterOutputStream

java.util.zip.DeflaterOutputStream

java.util.zip.ZipOutputStream

1234567891011121314151617181920212223242526importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.util.zip.ZipEntry;importjava.util.zip.ZipOutputStream;publicclassZipOutputStreamDemo1{publicstaticvoidmain(String[] args) throwsIOException{File file = newFile("d:"+ File.separator +"hello.txt");File zipFile = newFile("d:"+ File.separator +"hello.zip");InputStream input = newFileInputStream(file);ZipOutputStream zipOut = newZipOutputStream(newFileOutputStream(zipFile));zipOut.putNextEntry(newZipEntry(file.getName()));// 設置註釋zipOut.setComment("hello");inttemp = 0;while((temp = input.read()) != -1){zipOut.write(temp);}input.close();zipOut.close();}}

【案例】ZipOutputStream類壓縮多個文件

123456789101112131415161718192021222324252627282930313233343536importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.util.zip.ZipEntry;importjava.util.zip.ZipOutputStream;/*** 一次性壓縮多個文件* */publicclassZipOutputStreamDemo2{publicstaticvoidmain(String[] args) throwsIOException{// 要被壓縮的文件夾File file = newFile("d:"+ File.separator +"temp");File zipFile = newFile("d:"+ File.separator + "zipFile.zip");InputStream input = null;ZipOutputStream zipOut = newZipOutputStream(newFileOutputStream(zipFile));zipOut.setComment("hello");if(file.isDirectory()){File[] files = file.listFiles();for(inti = 0; i < files.length; ++i){input = newFileInputStream(files[i]);zipOut.putNextEntry(newZipEntry(file.getName()+ File.separator +files[i].getName()));inttemp = 0;while((temp = input.read()) !=-1){zipOut.write(temp);}input.close();}}zipOut.close();}}

【案例】ZipFile類展現

1234567891011121314importjava.io.File;importjava.io.IOException;importjava.util.zip.ZipFile;/***ZipFile演示* */publicclassZipFileDemo{publicstaticvoidmain(String[] args) throwsIOException{File file = newFile("d:"+ File.separator +"hello.zip");ZipFile zipFile = newZipFile(file);System.out.println("壓縮文件的名稱爲："+ zipFile.getName());}}

【案例】解壓縮文件（壓縮文件中只有一個文件的狀況）

123456789101112131415161718192021222324252627importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.OutputStream;importjava.util.zip.ZipEntry;importjava.util.zip.ZipFile;/*** 解壓縮文件（壓縮文件中只有一個文件的狀況）* */publicclassZipFileDemo2{publicstaticvoidmain(String[] args) throwsIOException{File file = newFile("d:"+ File.separator +"hello.zip");File outFile = newFile("d:"+ File.separator +"unZipFile.txt");ZipFile zipFile = newZipFile(file);ZipEntry entry =zipFile.getEntry("hello.txt");InputStream input = zipFile.getInputStream(entry);OutputStream output = newFileOutputStream(outFile);inttemp = 0;while((temp = input.read()) != -1){output.write(temp);}input.close();output.close();}}

【案例】ZipInputStream類解壓縮一個壓縮文件中包含多個文件的狀況

123456789101112131415161718192021222324252627282930313233343536373839404142importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.OutputStream;importjava.util.zip.ZipEntry;importjava.util.zip.ZipFile;importjava.util.zip.ZipInputStream;/*** 解壓縮一個壓縮文件中包含多個文件的狀況* */publicclassZipFileDemo3{publicstaticvoidmain(String[] args) throwsIOException{File file = newFile("d:"+File.separator + "zipFile.zip");File outFile = null;ZipFile zipFile = newZipFile(file);ZipInputStream zipInput = newZipInputStream(newFileInputStream(file));ZipEntry entry = null;InputStream input = null;OutputStream output = null;while((entry = zipInput.getNextEntry()) != null){System.out.println("解壓縮"+ entry.getName() + "文件");outFile = newFile("d:"+ File.separator + entry.getName());if(!outFile.getParentFile().exists()){outFile.getParentFile().mkdir();}if(!outFile.exists()){outFile.createNewFile();}input = zipFile.getInputStream(entry);output = newFileOutputStream(outFile);inttemp = 0;while((temp = input.read()) != -1){output.write(temp);}input.close();output.close();}}}

3.字節流的輸入與輸出的對應圖示

圖中藍色的爲主要的對應部分，紅色的部分就是不對應部分。紫色的虛線部分表明這些流通常要搭配使用。從上面的圖中能夠看出Java IO 中的字節流是極其對稱的。哲學上講「存在及合理」，如今咱們看看這些字節流中不太對稱的幾個類吧！

4.幾個特殊的輸入流類分析

LineNumberInputStream

主要完成從流中讀取數據時，會獲得相應的行號，至於何時分行、在哪裏分行是由改類主動肯定的，並非在原始中有這樣一個行號。在輸出部分沒有對應的部分，咱們徹底能夠本身創建一個LineNumberOutputStream，在最初寫入時會有一個基準的行號，之後每次遇到換行時會在下一行添加一個行號，看起來也是能夠的。好像更不入流了。

PushbackInputStream

其功能是查看最後一個字節，不滿意就放入緩衝區。主要用在編譯器的語法、詞法分析部分。輸出部分的BufferedOutputStream 幾乎實現相近的功能。

StringBufferInputStream

已經被Deprecated，自己就不該該出如今InputStream部分，主要由於String 應該屬於字符流的範圍。已經被廢棄了，固然輸出部分也沒有必要須要它了！還容許它存在只是爲了保持版本的向下兼容而已。

SequenceInputStream

能夠認爲是一個工具類，將兩個或者多個輸入流當成一個輸入流依次讀取。徹底能夠從IO 包中去除，還徹底不影響IO 包的結構，卻讓其更「純潔」――純潔的Decorator 模式。

【案例】將兩個文本文件合併爲另一個文本文件

12345678910111213141516171819202122232425262728293031importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.OutputStream;importjava.io.SequenceInputStream;/*** 將兩個文本文件合併爲另一個文本文件* */publicclassSequenceInputStreamDemo{publicstaticvoidmain(String[] args) throwsIOException{File file1 = newFile("d:"+ File.separator + "hello1.txt");File file2 = newFile("d:"+ File.separator + "hello2.txt");File file3 = newFile("d:"+ File.separator + "hello.txt");InputStream input1 =newFileInputStream(file1);InputStream input2 =newFileInputStream(file2);OutputStream output =newFileOutputStream(file3);// 合併流SequenceInputStreamsis = newSequenceInputStream(input1, input2);inttemp = 0;while((temp =sis.read()) != -1){output.write(temp);}input1.close();input2.close();output.close();sis.close();}}

PrintStream

也能夠認爲是一個輔助工具。主要能夠向其餘輸出流，或者FileInputStream 寫入數據，自己內部實現仍是帶緩衝的。本質上是對其它流的綜合運用的一個工具而已。同樣能夠踢出IO 包！System.err和System.out 就是PrintStream 的實例！

【案例】使用PrintStream進行輸出

1234567891011121314/*** 使用PrintStream進行輸出* */importjava.io.*;classhello {publicstaticvoidmain(String[] args) throwsIOException {PrintStream print = newPrintStream(newFileOutputStream(newFile("d:"+ File.separator +"hello.txt")));print.println(true);print.println("Rollen");print.close();}}

【案例】使用PrintStream進行格式化輸出

123456789101112131415/*** 使用PrintStream進行輸出* 並進行格式化* */importjava.io.*;classhello {publicstaticvoidmain(String[] args) throwsIOException {PrintStream print = newPrintStream(newFileOutputStream(newFile("d:"+ File.separator +"hello.txt")));String name="Rollen";intage=20;print.printf("姓名：%s. 年齡：%d.",name,age);print.close();}}

【案例】使用OutputStream向屏幕上輸出內容

12345678910111213141516171819/*** 使用OutputStream向屏幕上輸出內容* */importjava.io.*;classhello {publicstaticvoidmain(String[] args) throwsIOException {OutputStream out=System.out;try{out.write("hello".getBytes());}catch(Exception e) {e.printStackTrace();}try{out.close();}catch(Exception e) {e.printStackTrace();}}}

【案例】輸入輸出重定向

123456789101112131415161718192021importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.PrintStream;/*** 爲System.out.println()重定向輸出* */publicclasssystemDemo{publicstaticvoidmain(String[] args){// 此刻直接輸出到屏幕System.out.println("hello");File file = newFile("d:"+ File.separator +"hello.txt");try{System.setOut(newPrintStream(newFileOutputStream(file)));}catch(FileNotFoundException e){e.printStackTrace();}System.out.println("這些內容在文件中才能看到哦！");}}

【案例】使用System.err重定向

1234567891011121314151617181920importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.PrintStream;/***System.err重定向這個例子也提示咱們可使用這種方法保存錯誤信息* */publicclasssystemErr{publicstaticvoidmain(String[] args){File file = newFile("d:"+ File.separator +"hello.txt");System.err.println("這些在控制檯輸出");try{System.setErr(newPrintStream(newFileOutputStream(file)));}catch(FileNotFoundException e){e.printStackTrace();}System.err.println("這些在文件中才能看到哦！");}}

【案例】System.in重定向

1234567891011121314151617181920212223242526272829importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.IOException;/***System.in重定向* */publicclasssystemIn{publicstaticvoidmain(String[] args){File file = newFile("d:"+ File.separator +"hello.txt");if(!file.exists()){return;}else{try{System.setIn(newFileInputStream(file));}catch(FileNotFoundException e){e.printStackTrace();}byte[] bytes = newbyte[1024];intlen = 0;try{len = System.in.read(bytes);}catch(IOException e){e.printStackTrace();}System.out.println("讀入的內容爲："+ newString(bytes, 0, len));}}}

5.字符輸入流Reader

定義和說明：

在上面的繼承關係圖中能夠看出：

Reader 是全部的輸入字符流的父類，它是一個抽象類。

CharReader、StringReader是兩種基本的介質流，它們分別將Char 數組、String中讀取數據。PipedReader 是從與其它線程共用的管道中讀取數據。

BufferedReader 很明顯就是一個裝飾器，它和其子類負責裝飾其它Reader 對象。

FilterReader 是全部自定義具體裝飾流的父類，其子類PushbackReader 對Reader 對象進行裝飾，會增長一個行號。

InputStreamReader 是一個鏈接字節流和字符流的橋樑，它將字節流轉變爲字符流。FileReader能夠說是一個達到此功能、經常使用的工具類，在其源代碼中明顯使用了將 FileInputStream 轉變爲Reader 的方法。咱們能夠從這個類中獲得必定的技巧。Reader 中各個類的用途和使用方法基本和InputStream 中的類使用一致。後面會有Reader 與InputStream 的對應關係。

實例操做演示：

【案例】從文件中讀取內容

1234567891011121314151617/*** 字符流* 從文件中讀出內容* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);char[] ch=newchar[100];Reader read=newFileReader(f);intcount=read.read(ch);read.close();System.out.println("讀入的長度爲："+count);System.out.println("內容爲"+newString(ch,0,count));}}

注意：固然最好採用循環讀取的方式，由於咱們有時候不知道文件到底有多大。

【案例】以循環方式從文件中讀取內容

1234567891011121314151617181920/*** 字符流* 從文件中讀出內容* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);char[] ch=newchar[100];Reader read=newFileReader(f);inttemp=0;intcount=0;while((temp=read.read())!=(-1)){ch[count++]=(char)temp;}read.close();System.out.println("內容爲"+newString(ch,0,count));}}

【案例】BufferedReader的小例子

注意：BufferedReader只能接受字符流的緩衝區，由於每個中文須要佔據兩個字節，因此須要將System.in這個字節輸入流變爲字符輸入流，採用：

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

下面是一個實例：

123456789101112131415161718192021importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStreamReader;/*** 使用緩衝區從鍵盤上讀入內容* */publicclassBufferedReaderDemo{publicstaticvoidmain(String[] args){BufferedReader buf = newBufferedReader(newInputStreamReader(System.in));String str = null;System.out.println("請輸入內容");try{str = buf.readLine();}catch(IOException e){e.printStackTrace();}System.out.println("你輸入的內容是："+ str);}}

【案例】Scanner類實例

1234567891011121314151617importjava.util.Scanner;/***Scanner的小例子，從鍵盤讀數據* */publicclassScannerDemo{publicstatic voidmain(String[] args){Scanner sca = newScanner(System.in);// 讀一個整數inttemp = sca.nextInt();System.out.println(temp);//讀取浮點數floatflo=sca.nextFloat();System.out.println(flo);//讀取字符//...等等的，都是一些太基礎的，就不師範了。}}

【案例】Scanner類從文件中讀出內容

123456789101112131415161718192021importjava.io.File;importjava.io.FileNotFoundException;importjava.util.Scanner;/***Scanner的小例子，從文件中讀內容* */publicclassScannerDemo{publicstaticvoidmain(String[] args){File file = newFile("d:"+ File.separator +"hello.txt");Scanner sca = null;try{sca = newScanner(file);}catch(FileNotFoundException e){e.printStackTrace();}String str = sca.next();System.out.println("從文件中讀取的內容是："+ str);}}

6.字符輸出流Writer

定義和說明：

在上面的關係圖中能夠看出：

Writer 是全部的輸出字符流的父類，它是一個抽象類。

CharArrayWriter、StringWriter 是兩種基本的介質流，它們分別向Char 數組、String 中寫入數據。

PipedWriter 是向與其它線程共用的管道中寫入數據，

BufferedWriter 是一個裝飾器爲Writer 提供緩衝功能。

PrintWriter 和PrintStream 極其相似，功能和使用也很是類似。

OutputStreamWriter 是OutputStream 到Writer 轉換的橋樑，它的子類FileWriter 其實就是一個實現此功能的具體類（具體能夠研究一SourceCode）。功能和使用和OutputStream 極其相似，後面會有它們的對應圖。

實例操做演示：

【案例】向文件中寫入數據

123456789101112131415/*** 字符流* 寫入數據* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);Writer out =newFileWriter(f);String str="hello";out.write(str);out.close();}}

注意：這個例子上以前的例子沒什麼區別，只是你能夠直接輸入字符串，而不須要你將字符串轉化爲字節數組。當你若是想問文件中追加內容的時候，可使用將上面的聲明out的哪一行換爲：

Writer out =new FileWriter(f,true);

這樣，當你運行程序的時候，會發現文件內容變爲：hellohello若是想在文件中換行的話，須要使用「\r\n」好比將str變爲String str="\r\nhello";這樣文件追加的str的內容就會換行了。

7.字符流的輸入與輸出的對應

8.字符流與字節流轉換

轉換流的特色：

（1）其是字符流和字節流之間的橋樑

（2）可對讀取到的字節數據通過指定編碼轉換成字符

（3）可對讀取到的字符數據通過指定編碼轉換成字節

什麼時候使用轉換流？

當字節和字符之間有轉換動做時；

流操做的數據須要編碼或解碼時。

具體的對象體現：

InputStreamReader:字節到字符的橋樑

OutputStreamWriter:字符到字節的橋樑

這兩個流對象是字符體系中的成員，它們有轉換做用，自己又是字符流，因此在構造的時候須要傳入字節流對象進來。

字節流和字符流轉換實例：

【案例】將字節輸出流轉化爲字符輸出流

12345678910111213/*** 將字節輸出流轉化爲字符輸出流* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName= "d:"+File.separator+"hello.txt";File file=newFile(fileName);Writer out=newOutputStreamWriter(newFileOutputStream(file));out.write("hello");out.close();}}

【案例】將字節輸入流轉換爲字符輸入流

123456789101112131415/*** 將字節輸入流變爲字符輸入流* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) throwsIOException {String fileName= "d:"+File.separator+"hello.txt";File file=newFile(fileName);Reader read=newInputStreamReader(newFileInputStream(file));char[] b=newchar[100];intlen=read.read(b);System.out.println(newString(b,0,len));read.close();}}

9.File類

File類是對文件系統中文件以及文件夾進行封裝的對象，能夠經過對象的思想來操做文件和文件夾。 File類保存文件或目錄的各類元數據信息，包括文件名、文件長度、最後修改時間、是否可讀、獲取當前文件的路徑名，判斷指定文件是否存在、得到當前目錄中的文件列表，建立、刪除文件和目錄等方法。

【案例】建立一個文件

1234567891011importjava.io.*;classhello{publicstaticvoidmain(String[] args) {File f=newFile("D:\\hello.txt");try{f.createNewFile();}catch(Exception e) {e.printStackTrace();}}}

【案例2】File類的兩個常量

1234567importjava.io.*;classhello{publicstaticvoidmain(String[] args) {System.out.println(File.separator);System.out.println(File.pathSeparator);}}

此處多說幾句：有些同窗可能認爲，我直接在windows下使用\進行分割不行嗎？固然是能夠的。可是在linux下就不是\了。因此，要想使得咱們的代碼跨平臺，更加健壯，因此，你們都採用這兩個常量吧，其實也多寫不了幾行。

【案例3】File類中的常量改寫案例1的代碼：

123456789101112importjava.io.*;classhello{publicstaticvoidmain(String[] args) {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);try{f.createNewFile();}catch(Exception e) {e.printStackTrace();}}}

【案例4】刪除一個文件（或者文件夾）

12345678910111213importjava.io.*;classhello{publicstaticvoidmain(String[] args) {String fileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);if(f.exists()){f.delete();}else{System.out.println("文件不存在");}}}

【案例5】建立一個文件夾

1234567891011/*** 建立一個文件夾* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) {String fileName="D:"+File.separator+"hello";File f=newFile(fileName);f.mkdir();}}

【案例6】列出目錄下的全部文件

1234567891011121314/*** 使用list列出指定目錄的所有文件* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) {String fileName="D:"+File.separator;File f=newFile(fileName);String[] str=f.list();for(inti = 0; i < str.length; i++) {System.out.println(str[i]);}}}

注意使用list返回的是String數組，。並且列出的不是完整路徑，若是想列出完整路徑的話，須要使用listFiles.它返回的是File的數組。

【案例7】列出指定目錄的所有文件（包括隱藏文件）：

123456789101112131415/*** 使用listFiles列出指定目錄的所有文件* listFiles輸出的是完整路徑* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) {String fileName="D:"+File.separator;File f=newFile(fileName);File[] str=f.listFiles();for(inti = 0; i < str.length; i++) {System.out.println(str[i]);}}}

【案例8】判斷一個指定的路徑是否爲目錄

123456789101112131415/*** 使用isDirectory判斷一個指定的路徑是否爲目錄* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) {String fileName="D:"+File.separator;File f=newFile(fileName);if(f.isDirectory()){System.out.println("YES");}else{System.out.println("NO");}}}

【案例9】遞歸搜索指定目錄的所有內容，包括文件和文件夾

23456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319* 列出指定目錄的所有內容* */importjava.io.*;classhello{publicstaticvoidmain(String[] args) {String fileName="D:"+File.separator;File f=newFile(fileName);print(f);}publicstaticvoidprint(File f){if(f!=null){if(f.isDirectory()){File[] fileArray=f.listFiles();if(fileArray!=null){for(inti = 0; i <filearray.length; i++)=""{=""遞歸調用=""print(filearray[i]);=""}=""else{=""system.out.println(f);=""}<=""pre=""><h2>10.RandomAccessFile類</h2>該對象並非流體系中的一員，其封裝了字節流，同時還封裝了一個緩衝區（字符數組），經過內部的指針來操做字符數組中的數據。該對象特色：該對象只能操做文件，因此構造函數接收兩種類型的參數：a.字符串文件路徑；b.File對象。該對象既能夠對文件進行讀操做，也能進行寫操做，在進行對象實例化時可指定操做模式(r,rw)注意：該對象在實例化時，若是要操做的文件不存在，會自動建立；若是文件存在，寫數據未指定位置，會從頭開始寫，即覆蓋原有的內容。能夠用於多線程下載或多個線程同時寫數據到文件。【案例】使用RandomAccessFile寫入文件<pre class="brush:java;">/*** 使用RandomAccessFile寫入文件* */importjava.io.*;classhello{publicstaticvoidmain(String[]args) throwsIOException {StringfileName="D:"+File.separator+"hello.txt";File f=newFile(fileName);RandomAccessFile demo=newRandomAccessFile(f,"rw");demo.writeBytes("asdsad");demo.writeInt(12);demo.writeBoolean(true);demo.writeChar('A');demo.writeFloat(1.21f);demo.writeDouble(12.123);demo.close(); }}</pre><h1>Java IO流的高級概念</h1><h2>編碼問題</h2>【案例】取得本地的默認編碼<pre class="brush:java;">/*** 取得本地的默認編碼* */publicclass CharSetDemo{publicstaticvoidmain(String[] args){System.out.println("系統默認編碼爲："+ System.getProperty("file.encoding"));}}</pre>【案例】亂碼的產生<pre class="brush:java;">importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.OutputStream;/*** 亂碼的產生* */publicclassCharSetDemo2{publicstaticvoidmain(String[] args) throwsIOException{File file = newFile("d:"+ File.separator + "hello.txt");OutputStream out = newFileOutputStream(file);byte[] bytes = "你好".getBytes("ISO8859-1");out.write(bytes);out.close();}//輸出結果爲亂碼，系統默認編碼爲GBK，而此處編碼爲ISO8859-1}</pre><h2>對象的序列化</h2>對象序列化就是把一個對象變爲二進制數據流的一種方法。 一個類要想被序列化，就行必須實現java.io.Serializable接口。雖然這個接口中沒有任何方法，就如同以前的cloneable接口一樣。實現了這個接口以後，就表示這個類具備被序列化的能力。先讓咱們實現一個具備序列化能力的類吧：【案例】實現具備序列化能力的類<pre class="brush:java;">importjava.io.*;/*** 實現具備序列化能力的類* */publicclassSerializableDemo implementsSerializable{publicSerializableDemo(){}publicSerializableDemo(String name, intage){this.name=name;this.age=age;}@OverridepublicString toString(){return"姓名："+name+" 年齡："+age;}privateString name;privateintage;}</pre>【案例】序列化一個對象 – ObjectOutputStream<pre class="brush:java;">importjava.io.Serializable;importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.ObjectOutputStream;/*** 實現具備序列化能力的類* */publicclassPerson implementsSerializable{publicPerson(){}publicPerson(String name,intage){this.name = name;this.age = age;}@OverridepublicString toString(){return"姓名："+name + " 年齡："+age;}privateString name;privateintage;}/*** 示範ObjectOutputStream* */publicclassObjectOutputStreamDemo{publicstaticvoidmain(String[] args) throwsIOException{File file = newFile("d:"+ File.separator + "hello.txt");ObjectOutputStream oos= newObjectOutputStream(newFileOutputStream(file));oos.writeObject(newPerson("rollen", 20));oos.close();}}</pre>【案例】反序列化—ObjectInputStream<pre class="brush:java;">importjava.io.File;importjava.io.FileInputStream;importjava.io.ObjectInputStream;/*** ObjectInputStream示範* */publicclassObjectInputStreamDemo{publicstaticvoidmain(String[] args) throwsException{File file = newFile("d:"+File.separator + "hello.txt");ObjectInputStreaminput = newObjectInputStream(newFileInputStream(file));Object obj =input.readObject();input.close();System.out.println(obj);}}</pre>注意：被Serializable接口聲明的類的對象的屬性都將被序列化，可是若是想自定義序列化的內容的時候，就須要實現Externalizable接口。當一個類要使用Externalizable這個接口的時候，這個類中必需要有一個無參的構造函數，若是沒有的話，在構造的時候會產生異常，這是由於在反序列話的時候會默認調用無參的構造函數。如今咱們來演示一下序列化和反序列話：【案例】使用Externalizable來定製序列化和反序列化操做<pre class="brush:java;">packageIO;importjava.io.Externalizable;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.ObjectInput;importjava.io.ObjectInputStream;importjava.io.ObjectOutput;importjava.io.ObjectOutputStream;/*** 序列化和反序列化的操做* */publicclassExternalizableDemo{publicstaticvoidmain(String[] args) throwsException{ser(); // 序列化dser(); // 反序列話}publicstaticvoidser()throwsException{File file = newFile("d:"+ File.separator + "hello.txt");ObjectOutputStream out= newObjectOutputStream(newFileOutputStream(file));out.writeObject(newPerson("rollen", 20));out.close();}publicstaticvoiddser()throwsException{File file = newFile("d:"+ File.separator + "hello.txt");ObjectInputStreaminput = newObjectInputStream(newFileInputStream(file));Object obj =input.readObject();input.close();System.out.println(obj);}}classPerson implementsExternalizable{publicPerson(){}publicPerson(String name,intage){this.name = name;this.age = age;}@OverridepublicString toString(){return"姓名："+name + " 年齡："+age;}// 複寫這個方法，根據須要能夠保存的屬性或者具體內容，在序列化的時候使用@OverridepublicvoidwriteExternal(ObjectOutput out) throwsIOException{out.writeObject(this.name);out.writeInt(age);}// 複寫這個方法，根據須要讀取內容反序列話的時候須要@OverridepublicvoidreadExternal(ObjectInput in) throwsIOException,ClassNotFoundException{this.name = (String)in.readObject();this.age =in.readInt();}privateString name;privateintage;}</pre>注意：Serializable接口實現的操做實際上是吧一個對象中的所有屬性進行序列化，固然也可使用咱們上使用是Externalizable接口以實現部分屬性的序列化，可是這樣的操做比較麻煩，當咱們使用Serializable接口實現序列化操做的時候，若是一個對象的某一個屬性不想被序列化保存下來，那麼咱們可使用transient關鍵字進行說明：【案例】使用transient關鍵字定製序列化和反序列化操做<pre class="brush:java;">packageIO;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.ObjectInputStream;importjava.io.ObjectOutputStream;importjava.io.Serializable;/*** 序列化和反序列化的操做* */publicclassserDemo{publicstaticvoidmain(String[] args) throwsException{ser(); // 序列化dser(); // 反序列話}publicstaticvoidser()throwsException{File file = newFile("d:"+ File.separator + "hello.txt");ObjectOutputStream out= newObjectOutputStream(newFileOutputStream(file));out.writeObject(newPerson1("rollen", 20));out.close();}publicstaticvoiddser()throwsException{File file = newFile("d:"+ File.separator + "hello.txt");ObjectInputStreaminput = newObjectInputStream(newFileInputStream(file));Object obj =input.readObject();input.close();System.out.println(obj);}}classPerson1 implementsSerializable{publicPerson1(){}publicPerson1(Stringname, intage){this.name = name;this.age = age;}@OverridepublicString toString(){return"姓名："+name + " 年齡："+age;}// 注意這裏privatetransientStringname;privateintage;}</pre>【運行結果】：姓名：null年齡：20【案例】序列化一組對象<pre class="brush:java;">importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.ObjectInputStream;importjava.io.ObjectOutputStream;importjava.io.Serializable;/*** 序列化一組對象* */publicclassSerDemo1{publicstaticvoidmain(String[] args) throwsException{Student[] stu = { newStudent("hello", 20), newStudent("world", 30),newStudent("rollen", 40) };ser(stu);Object[] obj = dser();for(inti = 0; i <obj.length; ++i){=""student=""s="(Student)"obj[i];=""system.out.println(s);=""}=""序列化=""public=""static=""voidser(object[]=""obj)=""throws=""exception{=""file=""+=""file.separator="""hello.txt");=""objectoutputstream=""out="new"objectoutputstream(new=""fileoutputstream(=""file));=""out.writeobject(obj);=""out.close();=""反序列化=""object[]dser()=""objectinputstreaminput="new"objectinputstream(new=""fileinputstream(=""object[]=""obj="(Object[])"input.readobject();=""input.close();=""return=""obj;=""class=""implements=""serializable{=""student(){=""student(stringname,=""int=""age){=""this.name="name;"this.age="age;"@override=""string=""tostring(){="""姓名：="" "=""name=""年齡："="" age;="" private="" name;="" }<="" pre=""><h1>參考文獻：</h1>一、http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html二、http://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html<h3></h3> </obj.length;></pre></filearray.length;