1.什么是IO

Java中I/O操作主要是指使用Java進行輸入，輸出操作.?Java所有的I/O機制都是基于數(shù)據(jù)流進行輸入輸出，這些數(shù)據(jù)流表示了字符或者字節(jié)數(shù)據(jù)的流動序列。Java的I/O流提供了讀寫數(shù)據(jù)的標(biāo)準(zhǔn)方法。任何Java中表示數(shù)據(jù)源的對象都會提供以數(shù)據(jù)流的方式讀寫它的數(shù)據(jù)的方法。

Java.io是大多數(shù)面向數(shù)據(jù)流的輸入/輸出類的主要軟件包。此外，Java也對塊傳輸提供支持，在核心庫 java.nio中采用的便是塊IO。

流IO的好處是簡單易用，缺點是效率較低。塊IO效率很高，但編程比較復(fù)雜。

Java IO模型 ?:

Java的IO模型設(shè)計非常優(yōu)秀，它使用Decorator模式，按功能劃分Stream，您可以動態(tài)裝配這些Stream，以便獲得您需要的功能。例如，您需要一個具有緩沖的文件輸入流，則應(yīng)當(dāng)組合使用FileInputStream和BufferedInputStream。

2.數(shù)據(jù)流的基本概念

數(shù)據(jù)流是一串連續(xù)不斷的數(shù)據(jù)的集合，就象水管里的水流，在水管的一端一點一點地供水，而在水管的另一端看到的是一股連續(xù)不斷的水流。數(shù)據(jù)寫入程序可以是一段、一段地向數(shù)據(jù)流管道中寫入數(shù)據(jù)，這些數(shù)據(jù)段會按先后順序形成一個長的數(shù)據(jù)流。對數(shù)據(jù)讀取程序來說，看不到數(shù)據(jù)流在寫入時的分段情況，每次可以讀取其中的任意長度的數(shù)據(jù)，但只能先讀取前面的數(shù)據(jù)后，再讀取后面的數(shù)據(jù)。不管寫入時是將數(shù)據(jù)分多次寫入，還是作為一個整體一次寫入，讀取時的效果都是完全一樣的。

“流是磁盤或其它外圍設(shè)備中存儲的數(shù)據(jù)的源點或終點。”

在電腦上的數(shù)據(jù)有三種存儲方式，一種是外存，一種是內(nèi)存，一種是緩存。比如電腦上的硬盤，磁盤，U盤等都是外存，在電腦上有內(nèi)存條，緩存是在CPU里面的。外存的存儲量最大，其次是內(nèi)存，最后是緩存，但是外存的數(shù)據(jù)的讀取最慢，其次是內(nèi)存，緩存最快。這里總結(jié)從外存讀取數(shù)據(jù)到內(nèi)存以及將數(shù)據(jù)從內(nèi)存寫到外存中。對于內(nèi)存和外存的理解，我們可以簡單的理解為容器，即外存是一個容器，內(nèi)存又是另外一個容器。那又怎樣把放在外存這個容器內(nèi)的數(shù)據(jù)讀取到內(nèi)存這個容器以及怎么把內(nèi)存這個容器里的數(shù)據(jù)存到外存中呢？

在Java類庫中，IO部分的內(nèi)容是很龐大的，因為它涉及的領(lǐng)域很廣泛:

標(biāo)準(zhǔn)輸入輸出，文件的操作，網(wǎng)絡(luò)上的數(shù)據(jù)流，字符串流，對象流，zip文件流等等，java中將輸入輸出抽象稱為流，就好像水管，將兩個容器連接起來。將數(shù)據(jù)沖外存中讀取到內(nèi)存中的稱為輸入流，將數(shù)據(jù)從內(nèi)存寫入外存中的稱為輸出流。

流是一個很形象的概念，當(dāng)程序需要讀取數(shù)據(jù)的時候，就會開啟一個通向數(shù)據(jù)源的流，這個數(shù)據(jù)源可以是文件，內(nèi)存，或是網(wǎng)絡(luò)連接。類似的，當(dāng)程序需要寫入數(shù)據(jù)的時候，就會開啟一個通向目的地的流。

總結(jié)的基本概念如下：

1) 數(shù)據(jù)流：

一組有序，有起點和終點的字節(jié)的數(shù)據(jù)序列。包括輸入流和輸出流。

2) 輸入流(Input ?Stream)：

程序從輸入流讀取數(shù)據(jù)源。數(shù)據(jù)源包括外界(鍵盤、文件、網(wǎng)絡(luò)…)，即是將數(shù)據(jù)源讀入到程序的通信通道

3) 輸出流：

程序向輸出流寫入數(shù)據(jù)。將程序中的數(shù)據(jù)輸出到外界(顯示器、打印機、文件、網(wǎng)絡(luò)…)的通信通道。

采用數(shù)據(jù)流的目的就是使得輸出輸入獨立于設(shè)備。

Input ?Stream不關(guān)心數(shù)據(jù)源來自何種設(shè)備(鍵盤，文件，網(wǎng)絡(luò))

Output ?Stream不關(guān)心數(shù)據(jù)的目的是何種設(shè)備(鍵盤，文件，網(wǎng)絡(luò))

4 數(shù)據(jù)流分類：

流序列中的數(shù)據(jù)既可以是未經(jīng)加工的原始二進制數(shù)據(jù)，也可以是經(jīng)一定編碼處理后符合某種格式規(guī)定的特定數(shù)據(jù)。因此Java中的流分為兩種：

1) ?字節(jié)流：數(shù)據(jù)流中最小的數(shù)據(jù)單元是字節(jié)

2) ?字符流：數(shù)據(jù)流中最小的數(shù)據(jù)單元是字符， Java中的字符是Unicode編碼，一個字符占用兩個字節(jié)。

3.?標(biāo)準(zhǔn)I/O

Java程序可通過命令行參數(shù)與外界進行簡短的信息交換，同時，也規(guī)定了與標(biāo)準(zhǔn)輸入、輸出設(shè)備，如鍵盤、顯示器進行信息交換的方式。而通過文件可以與外界進行任意數(shù)據(jù)形式的信息交換。

=======================================================================================

1. 命令行參數(shù)

publicclassTestArgs?{

publicstaticvoidmain(String[]?args)?{

for(inti?=0;?i?

System.out.println("args["+?i?+"]?is?");

}

}

}

運行命令：java Java C VB

運行結(jié)果：

args[0] is

args[1] is

args[2] is

=======================================================================================

2. 標(biāo)準(zhǔn)輸入，輸出數(shù)據(jù)流

java系統(tǒng)自帶的標(biāo)準(zhǔn)數(shù)據(jù)流：java.lang.System:

java.lang.System

publicfinalclassSystemextendsObject{

staticPrintStream??err;//標(biāo)準(zhǔn)錯誤流(輸出)

staticInputStream??in;//標(biāo)準(zhǔn)輸入(鍵盤輸入流)

staticPrintStream??out;//標(biāo)準(zhǔn)輸出流(顯示器輸出流)

}

注意：

(1)System類不能創(chuàng)建對象，只能直接使用它的三個靜態(tài)成員。

(2)每當(dāng)main方法被執(zhí)行時,就自動生成上述三個對象。

1) 標(biāo)準(zhǔn)輸出流?System.out

System.out向標(biāo)準(zhǔn)輸出設(shè)備輸出數(shù)據(jù)，其數(shù)據(jù)類型為PrintStream。方法：

Void print(參數(shù))

Void println(參數(shù))

2)標(biāo)準(zhǔn)輸入流?System.in

System.in讀取標(biāo)準(zhǔn)輸入設(shè)備數(shù)據(jù)(從標(biāo)準(zhǔn)輸入獲取數(shù)據(jù)，一般是鍵盤)，其數(shù) 據(jù)類型為InputStream。方法：

int read()//返回ASCII碼。若,返回值=-1，說明沒有讀取到任何字節(jié)讀取工作結(jié)束。

int read(byte[] b)//讀入多個字節(jié)到緩沖區(qū)b中返回值是讀入的字節(jié)數(shù)

例如：

importjava.io.*;

publicclassStandardInputOutput?{

publicstaticvoidmain(String?args[])?{

intb;

try{

System.out.println("please?Input:");

while((b?=?System.in.read())?!=?-1)?{

System.out.print((char)?b);

}

}?catch(IOException?e)?{

System.out.println(e.toString());

}

}

}

等待鍵盤輸入，鍵盤輸入什么，就打印出什么：

3)標(biāo)準(zhǔn)錯誤流

System.err輸出標(biāo)準(zhǔn)錯誤，其數(shù)據(jù)類型為PrintStream。可查閱API獲得詳細說明。

標(biāo)準(zhǔn)輸出通過System.out調(diào)用println方法輸出參數(shù)并換行，而print方法輸出參數(shù)但不換行。println或print方法都通 過重載實現(xiàn)了輸出基本數(shù)據(jù)類型的多個方法，包括輸出參數(shù)類型為boolean、char、int、long、float和double。同時，也重載實現(xiàn) 了輸出參數(shù)類型為char[]、String和Object的方法。其中，print(Object)和println(Object)方法在運行時將調(diào) 用參數(shù)Object的toString方法。

importjava.io.BufferedReader;

importjava.io.IOException;

importjava.io.InputStreamReader;

publicclassStandardInputOutput?{

publicstaticvoidmain(String?args[])?{

String?s;

//?創(chuàng)建緩沖區(qū)閱讀器從鍵盤逐行讀入數(shù)據(jù)

InputStreamReader?ir?=?newInputStreamReader(System.in);

BufferedReader?in?=?newBufferedReader(ir);

System.out.println("Unix系統(tǒng):?ctrl-d?或?ctrl-c?退出"

+?"\nWindows系統(tǒng):?ctrl-z?退出");

try{

//?讀一行數(shù)據(jù)，并標(biāo)準(zhǔn)輸出至顯示器

s?=?in.readLine();

//?readLine()方法運行時若發(fā)生I/O錯誤，將拋出IOException異常

while(s?!=null)?{

System.out.println("Read:?"+?s);

s?=?in.readLine();

}

//?關(guān)閉緩沖閱讀器

in.close();

}?catch(IOException?e)?{//?Catch?any?IO?exceptions.

e.printStackTrace();

}

}

}

=======================================================================================

4.java.IO層次體系結(jié)構(gòu)

在整個Java.io包中最重要的就是5個類和一個接口。5個類指的是File、OutputStream、InputStream、Writer、Reader；一個接口指的是Serializable.掌握了這些IO的核心操作那么對于Java中的IO體系也就有了一個初步的認(rèn)識了

Java I/O主要包括如下幾個層次，包含三個部分：

1.流式部分――IO的主體部分；

2.非流式部分――主要包含一些輔助流式部分的類，如：File類、RandomAccessFile類和FileDescriptor等類；

3.其他類--文件讀取部分的與安全相關(guān)的類，如：SerializablePermission類，以及與本地操作系統(tǒng)相關(guān)的文件系統(tǒng)的類，如：FileSystem類和Win32FileSystem類和WinNTFileSystem類。

主要的類如下：

1. File(文件特征與管理)：用于文件或者目錄的描述信息，例如生成新目錄，修改文件名，刪除文件，判斷文件所在路徑等。

2. InputStream(二進制格式操作)：抽象類，基于字節(jié)的輸入操作，是所有輸入流的父類。定義了所有輸入流都具有的共同特征。

3. OutputStream(二進制格式操作)：抽象類。基于字節(jié)的輸出操作。是所有輸出流的父類。定義了所有輸出流都具有的共同特征。

Java中字符是采用Unicode標(biāo)準(zhǔn)，一個字符是16位，即一個字符使用兩個字節(jié)來表示。為此，JAVA中引入了處理字符的流。

4. Reader(文件格式操作)：抽象類，基于字符的輸入操作。

5. Writer(文件格式操作)：抽象類，基于字符的輸出操作。

6. RandomAccessFile(隨機文件操作)：它的功能豐富，可以從文件的任意位置進行存取(輸入輸出)操作。

Java中IO流的體系結(jié)構(gòu)如圖：

=======================================================================================

5. 非流式文件類--File類

在Java語言的java.io包中，由File類提供了描述文件和目錄的操作與管理方法。但File類不是InputStream、OutputStream或Reader、Writer的子類，因為它不負(fù)責(zé)數(shù)據(jù)的輸入輸出，而專門用來管理磁盤文件與目錄。

作用：File類主要用于命名文件、查詢文件屬性和處理文件目錄。

publicclassFileextendsObject

implementsSerializable,Comparable

{}

File類共提供了三個不同的構(gòu)造函數(shù)，以不同的參數(shù)形式靈活地接收文件和目錄名信息。構(gòu)造函數(shù)：

1)File (String ? pathname)

例:File ?f1=new File("FileTest1.txt");?//創(chuàng)建文件對象f1，f1所指的文件是在當(dāng)前目錄下創(chuàng)建的FileTest1.txt

2)File (String ?parent ?, ?String child)

例:File f2=new ?File(“D:\\dir1","FileTest2.txt") ;// ?注意：D:\\dir1目錄事先必須存在，否則異常

3)File (File ? ?parent ?, String child)

例:File ?f4=new File("\\dir3");

File ?f5=new File(f4,"FileTest5.txt");??//在如果 \\dir3目錄不存在使用f4.mkdir()先創(chuàng)建

一個對應(yīng)于某磁盤文件或目錄的File對象一經(jīng)創(chuàng)建， 就可以通過調(diào)用它的方法來獲得文件或目錄的屬性。

1)public boolean exists( )?判斷文件或目錄是否存在

2)public boolean isFile( )?判斷是文件還是目錄

3)public boolean isDirectory( )判斷是文件還是目錄

4)public String getName( )返回文件名或目錄名

5)public String getPath( )返回文件或目錄的路徑。

6)public long length( )獲取文件的長度

7)public String[ ] list ( )將目錄中所有文件名保存在字符串?dāng)?shù)組中返回。

File類中還定義了一些對文件或目錄進行管理、操作的方法，常用的方法有：

1)?public boolean renameTo( File newFile ); ? ?重命名文件

2)?public void delete( ); ??刪除文件

3)??public boolean mkdir( );?創(chuàng)建目錄

例子：

importjava.io.File;

importjava.io.IOException;

publicclassTestFile?{

publicstaticvoidmain(String?args[])throwsIOException?{

File?dir?=?newFile("\\root");

File?f1?=?newFile(dir,"fileOne.txt");

File?f2?=?newFile(dir,"fileTwo.java");

//?文件對象創(chuàng)建后，指定的文件或目錄不一定物理上存在

if(!dir.exists())

dir.mkdir();

if(!f1.exists())

f1.createNewFile();

if(!f2.exists())

f2.createNewFile();

System.out.println("f1's?AbsolutePath=??"+?f1.getAbsolutePath());

System.out.println("f1?Canread="+?f1.canRead());

System.out.println("f1's?len=?"+?f1.length());

String[]?FL;

intcount?=0;

FL?=?dir.list();

for(inti?=0;?i?

count++;

System.out.println(FL[i]?+?"is?in?\\root");

}

System.out.println("there?are"+?count?+"file?in?//root");

}

}

說明：File類的方法:

(1) exists()測試磁盤中指定的文件或目錄是否存在

(2) mkdir()創(chuàng)建文件對象指定的目錄(單層目錄)

(3) createNewFile()創(chuàng)建文件對象指定的文件

(4) list()返回目錄中所有文件名字符串

=======================================================================================

6. Java.IO流類庫

1. io流的四個基本類

java.io包中包含了流式I/O所需要的所有類。在java.io包中有四個基本類：InputStream、OutputStream及Reader、Writer類，它們分別處理字節(jié)流和字符流：

基本數(shù)據(jù)流的I/O

輸入/輸出

字節(jié)流

字符流

輸入流

Inputstream

Reader

輸出流

OutputStream

Writer

Java中其他多種多樣變化的流均是由它們派生出來的:

JDK1.4版本開始引入了新I/O類庫，它位于java.nio包中，新I/O類庫利用通道和緩沖區(qū)等來提高I/O操作的效率。

在java.io包中， java.io.InputStream 表示字節(jié)輸入流， java.io.OutputStream表示字節(jié)輸出流，處于java.io包最頂層。這兩個類均為抽象類，也就是說它們不能被實例化，必須生成子類之后才能實現(xiàn)一定的功能。

1. io流的具體分類

一、按I/O類型來總體分類：

1. Memory1)從/向內(nèi)存數(shù)組讀寫數(shù)據(jù): CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream

2)從/向內(nèi)存字符串讀寫數(shù)據(jù) StringReader、StringWriter、StringBufferInputStream

2.Pipe管道實現(xiàn)管道的輸入和輸出(進程間通信): PipedReader、PipedWriter、PipedInputStream、PipedOutputStream

3.File 文件流。對文件進行讀、寫操作 ：FileReader、FileWriter、FileInputStream、FileOutputStream

4. ObjectSerialization 對象輸入、輸出?(序列化)：ObjectInputStream、ObjectOutputStream

5.DataConversion數(shù)據(jù)流按基本數(shù)據(jù)類型讀、寫(處理的數(shù)據(jù)是Java的基本類型(如布爾型，字節(jié)，整數(shù)和浮點數(shù)))：DataInputStream、DataOutputStream

6.Printing包含方便的打印方法 ：PrintWriter、PrintStream

7.Buffering緩沖在讀入或?qū)懗鰰r，對數(shù)據(jù)進行緩存，以減少I/O的次數(shù)：BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream

8.Filtering濾流，在數(shù)據(jù)進行讀或?qū)憰r進行過濾：FilterReader、FilterWriter、FilterInputStream、FilterOutputStream過

9.Concatenation合并輸入把多個輸入流連接成一個輸入流 ：SequenceInputStream

10.Counting計數(shù)在讀入數(shù)據(jù)時對行記數(shù) ：LineNumberReader、LineNumberInputStream

11.Peeking Ahead通過緩存機制，進行預(yù)讀 ：PushbackReader、PushbackInputStream

12.Converting between Bytes and Characters按照一定的編碼/解碼標(biāo)準(zhǔn)將字節(jié)流轉(zhuǎn)換為字符流，或進行反向轉(zhuǎn)換(Stream到Reader,Writer的轉(zhuǎn)換類)：InputStreamReader、OutputStreamWriter

二、按數(shù)據(jù)來源(去向)分類：

1、File(文件)： FileInputStream, FileOutputStream, FileReader, FileWriter

2、byte[]：ByteArrayInputStream, ByteArrayOutputStream

3、Char[]: CharArrayReader, CharArrayWriter

4、String: StringBufferInputStream, StringReader, StringWriter

5、網(wǎng)絡(luò)數(shù)據(jù)流：InputStream, OutputStream, Reader, Writer

=======================================================================================

7. 字節(jié)流InputStream/OutputStream

1. InputStream抽象類

InputStream 為字節(jié)輸入流，它本身為一個抽象類，必須依靠其子類實現(xiàn)各種功能，此抽象類是表示字節(jié)輸入流的所有類的超類。繼承自InputStream

的流都是向程序中輸入數(shù)據(jù)的，且數(shù)據(jù)單位為字節(jié)(8bit)；

InputStream是輸入字節(jié)數(shù)據(jù)用的類，所以InputStream類提供了3種重載的read方法.Inputstream類中的常用方法：

(1) public abstract int read( )：讀取一個byte的數(shù)據(jù)，返回值是高位補0的int類型值。若返回值=-1說明沒有讀取到任何字節(jié)讀取工作結(jié)束。

(2) public int read(byte b[ ])：讀取b.length個字節(jié)的數(shù)據(jù)放到b數(shù)組中。返回值是讀取的字節(jié)數(shù)。該方法實際上是調(diào)用下一個方法實現(xiàn)的

(3) public int read(byte b[ ], int off, int len)：從輸入流中最多讀取len個字節(jié)的數(shù)據(jù)，存放到偏移量為off的b數(shù)組中。

(4) public int available( )：返回輸入流中可以讀取的字節(jié)數(shù)。注意：若輸入阻塞，當(dāng)前線程將被掛起，如果InputStream對象調(diào)用這個方法的話，它只會返回0，這個方法必須由繼承InputStream類的子類對象調(diào)用才有用，

(5) public long skip(long n)：忽略輸入流中的n個字節(jié)，返回值是實際忽略的字節(jié)數(shù), 跳過一些字節(jié)來讀取

(6) public int close( ) ：我們在使用完后，必須對我們打開的流進行關(guān)閉.

主要的子類：

1) FileInputStream把一個文件作為InputStream，實現(xiàn)對文件的讀取操作

2) ByteArrayInputStream：把內(nèi)存中的一個緩沖區(qū)作為InputStream使用

3) StringBufferInputStream：把一個String對象作為InputStream

4) PipedInputStream：實現(xiàn)了pipe的概念，主要在線程中使用

5) SequenceInputStream：把多個InputStream合并為一個InputStream

2．OutputStream抽象類

OutputStream提供了3個write方法來做數(shù)據(jù)的輸出，這個是和InputStream是相對應(yīng)的。

1. public void write(byte b[ ])：將參數(shù)b中的字節(jié)寫到輸出流。

2. public void write(byte b[ ], int off, int len) ：將參數(shù)b的從偏移量off開始的len個字節(jié)寫到輸出流。

3. public abstract void write(int b) ：先將int轉(zhuǎn)換為byte類型，把低字節(jié)寫入到輸出流中。

4. public void flush( ) : 將數(shù)據(jù)緩沖區(qū)中數(shù)據(jù)全部輸出，并清空緩沖區(qū)。

5. public void close( ) : 關(guān)閉輸出流并釋放與流相關(guān)的系統(tǒng)資源。

主要的子類：

1) ByteArrayOutputStream：把信息存入內(nèi)存中的一個緩沖區(qū)中

2) FileOutputStream：把信息存入文件中

3) PipedOutputStream：實現(xiàn)了pipe的概念，主要在線程中使用

4) SequenceOutputStream：把多個OutStream合并為一個OutStream

流結(jié)束的判斷：方法read()的返回值為-1時；readLine()的返回值為null時。

3. 文件輸入流： FileInputStream類

FileInputStream可以使用read()方法一次讀入一個字節(jié)，并以int類型返回，或者是使用read()方法時讀入至一個byte數(shù)組，byte數(shù)組的元素有多少個，就讀入多少個字節(jié)。在將整個文件讀取完成或?qū)懭胪戤叺倪^程中，這么一個byte數(shù)組通常被當(dāng)作緩沖區(qū)，因為這么一個byte數(shù)組通常扮演承接數(shù)據(jù)的中間角色。

作用：以文件作為數(shù)據(jù)輸入源的數(shù)據(jù)流。或者說是打開文件，從文件讀數(shù)據(jù)到內(nèi)存的類。

使用方法(1)

File ?fin=new File("d:/abc.txt");

FileInputStream in=new FileInputStream( fin);

使用方法(2)

FileInputStream ?in=new??FileInputStream(“d: /abc.txt”);

程序舉例：

將InputFromFile.java的程序的內(nèi)容顯示在顯示器上

importjava.io.IOException;

importjava.io.FileInputStream;

;

publicclassTestFile?{

publicstaticvoidmain(String?args[])throwsIOException?{

try{

FileInputStream?rf=newFileInputStream("InputFromFile.java");

intn=512;bytebuffer[]=newbyte[n];

while((rf.read(buffer,0,n)!=-1)&&(n>0)){

System.out.println(newString(buffer)?);

}

System.out.println();

rf.close();

}?catch(IOException??IOe){

System.out.println(IOe.toString());

}

}

}

4.文件輸出流:FileOutputStream類

作用：用來處理以文件作為數(shù)據(jù)輸出目的數(shù)據(jù)流；或者說是從內(nèi)存區(qū)讀數(shù)據(jù)入文件

FileOutputStream類用來處理以文件作為數(shù)據(jù)輸出目的數(shù)據(jù)流；一個表示文件名的字符串，也可以是File或FileDescriptor對象。

創(chuàng)建一個文件流對象有兩種方法：

方式1：

File ? f=new ?File (“d:/myjava/write.txt ");

FileOutputStream ?out= new FileOutputStream (f);

方式2：

FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt ");

方式3：構(gòu)造函數(shù)將 FileDescriptor()對象作為其參數(shù)。

FileDescriptor() fd=new FileDescriptor();

FileOutputStream f2=new FileOutputStream(fd);

方式4：構(gòu)造函數(shù)將文件名作為其第一參數(shù)，將布爾值作為第二參數(shù)。

FileOutputStream f=new FileOutputStream("d:/abc.txt",true);

注意：?(1)文件中寫數(shù)據(jù)時，若文件已經(jīng)存在，則覆蓋存在的文件；(2)的讀/寫操作結(jié)束時，應(yīng)調(diào)用close方法關(guān)閉流。

程序舉例：使用鍵盤輸入一段文章，將文章保存在文件write.txt中

importjava.io.IOException;

importjava.io.FileOutputStream;

publicclassTestFile?{

publicstaticvoidmain(String?args[])throwsIOException?{

try{

System.out.println("please?Input?from??????Keyboard");

intcount,?n?=512;

bytebuffer[]?=newbyte[n];

count?=?System.in.read(buffer);

FileOutputStream?wf?=?newFileOutputStream("d:/myjava/write.txt");

wf.write(buffer,?0,?count);

wf.close();?//?當(dāng)流寫操作結(jié)束時，調(diào)用close方法關(guān)閉流。

System.out.println("Save?to?the?write.txt");

}?catch(IOException?IOe)?{

System.out.println("File?Write?Error!");

}

}

}

5. FileInputStream流和FileOutputStream的應(yīng)用

利用程序?qū)⑽募ile1.txt 拷貝到file2.txt中。

importjava.io.File;

importjava.io.IOException;

importjava.io.FileOutputStream;

importjava.io.FileInputStream;

publicclassTestFile?{

publicstaticvoidmain(String?args[])throwsIOException?{

try{

File?inFile?=?newFile("copy.java");

File?outFile?=?newFile("copy2.java");

FileInputStream?finS?=?newFileInputStream(inFile);

FileOutputStream?foutS?=?newFileOutputStream(outFile);

intc;

while((c?=?finS.read())?!=?-1)?{

foutS.write(c);

}

finS.close();

foutS.close();

}?catch(IOException?e)?{

System.err.println("FileStreamsTest:?"+?e);

}

}

}

6. 緩沖輸入輸出流BufferedInputStream/?BufferedOutputStream

計算機訪問外部設(shè)備非常耗時。訪問外存的頻率越高，造成CPU閑置的概率就越大。為了減少訪問外存的次數(shù)，應(yīng)該在一次對外設(shè)的訪問中，讀寫更多的數(shù)據(jù)。為此，除了程序和流節(jié)點間交換數(shù)據(jù)必需的讀寫機制外，還應(yīng)該增加緩沖機制。緩沖流就是每一個數(shù)據(jù)流分配一個緩沖區(qū)，一個緩沖區(qū)就是一個臨時存儲數(shù)據(jù)的內(nèi)存。這樣可以減少訪問硬盤的次數(shù),提高傳輸效率。

BufferedInputStream:當(dāng)向緩沖流寫入數(shù)據(jù)時候，數(shù)據(jù)先寫到緩沖區(qū)，待緩沖區(qū)寫滿后，系統(tǒng)一次性將數(shù)據(jù)發(fā)送給輸出設(shè)備。

BufferedOutputStream :當(dāng)從向緩沖流讀取數(shù)據(jù)時候，系統(tǒng)先從緩沖區(qū)讀出數(shù)據(jù)，待緩沖區(qū)為空時，系統(tǒng)再從輸入設(shè)備讀取數(shù)據(jù)到緩沖區(qū)。

1)將文件讀入內(nèi)存：

將BufferedInputStream與FileInputStream相接

FileInputStream?in=new??FileInputStream( “file1.txt ” );

BufferedInputStream?bin=new??BufferedInputStream(?in);

2)將內(nèi)存寫入文件：

將BufferedOutputStream與FileOutputStream相接

FileOutputStreamout=new?FileOutputStream(“file1.txt”);

BufferedOutputStream??bin=new?BufferedInputStream(out);

3)鍵盤輸入流讀到內(nèi)存

將BufferedReader與標(biāo)準(zhǔn)的數(shù)據(jù)流相接

InputStreamReader?sin=new?InputStreamReader (System.in) ；

BufferedReader bin=new ? ? ? ? ? ??BufferedReader(sin);

importjava.io.*;

publicclassReadWriteToFile?{

publicstaticvoidmain(String?args[])throwsIOException?{

InputStreamReader?sin?=?newInputStreamReader(System.in);

BufferedReader?bin?=?newBufferedReader(sin);

FileWriter?out?=?newFileWriter("myfile.txt");

BufferedWriter?bout?=?newBufferedWriter(out);

String?s;

while((s?=?bin.readLine()).length()?>0)?{

bout.write(s,?0,?s.length());

}

}

}

程序說明：

從鍵盤讀入字符，并寫入到文件中BufferedReader類的方法：String

readLine()

作用：讀一行字符串，以回車符為結(jié)束。

BufferedWriter類的方法：bout.write(String

s,offset,len)

作用：從緩沖區(qū)將字符串s從offset開始，len長度的字符串寫到某處。

8. 字符流Writer/Reader

Java中字符是采用Unicode標(biāo)準(zhǔn)，一個字符是16位，即一個字符使用兩個字節(jié)來表示。為此，JAVA中引入了處理字符的流。

1. Reader抽象類

用于讀取字符流的抽象類。子類必須實現(xiàn)的方法只有 read(char[], int, int) 和 close()。但是，多數(shù)子類將重寫此處定義的一些方法，以提供更高的效率和/或其他功能。

1) FileReader :與FileInputStream對應(yīng)

主要用來讀取字符文件，使用缺省的字符編碼，有三種構(gòu)造函數(shù)：

(1)將文件名作為字符串 ：FileReader f=new FileReader(“c:/temp.txt”);

(2)構(gòu)造函數(shù)將File對象作為其參數(shù)。

File f=new file(“c:/temp.txt”);

FileReader f1=new FileReader(f);

(3) ?構(gòu)造函數(shù)將FileDescriptor對象作為參數(shù)

FileDescriptor() fd=new FileDescriptor()

FileReader f2=new FileReader(fd);

(1) 用指定字符數(shù)組作為參數(shù)：CharArrayReader(char[])

(2) 將字符數(shù)組作為輸入流:CharArrayReader(char[], int, int)

讀取字符串，構(gòu)造函數(shù)如下： public StringReader(String s);

2) CharArrayReader：與ByteArrayInputStream對應(yīng)

3) StringReader :與StringBufferInputStream對應(yīng)

4) InputStreamReader

從輸入流讀取字節(jié)，在將它們轉(zhuǎn)換成字符:Public inputstreamReader(inputstream is);

5) FilterReader:允許過濾字符流

protected filterReader(Reader r);

6) BufferReader :接受Reader對象作為參數(shù)，并對其添加字符緩沖器，使用readline()方法可以讀取一行。

Public BufferReader(Reader r);

主要方法：

(1)

public?int?read()?throws?IOException;?//讀取一個字符，返回值為讀取的字符

(2) ?public?int?read(char?cbuf[])?throws?IOException;?/*讀取一系列字符到數(shù)組cbuf[]中，返回值為實際讀取的字符的數(shù)量*/(3) ?public?abstract?int?read(char?cbuf[],int?off,int?len)?throws?IOException;/*讀取len個字符，從數(shù)組cbuf[]的下標(biāo)off處開始存放，返回值為實際讀取的字符數(shù)量，該方法必須由子類實現(xiàn)*/

2. Writer抽象類

寫入字符流的抽象類。子類必須實現(xiàn)的方法僅有 write(char[], int, int)、flush() 和 close()。但是，多數(shù)子類將重寫此處定義的一些方法，以提供更高的效率和/或其他功能。 其子類如下：

1) FileWrite:與FileOutputStream對應(yīng)

將字符類型數(shù)據(jù)寫入文件，使用缺省字符編碼和緩沖器大小。

Public FileWrite(file f);2) ?chararrayWrite:與ByteArrayOutputStream對應(yīng) ,將字符緩沖器用作輸出。

Public CharArrayWrite();

3) PrintWrite:生成格式化輸出

public PrintWriter(outputstream os);

4) filterWriter:用于寫入過濾字符流

protected FilterWriter(Writer w);

5) PipedWriter：與PipedOutputStream對應(yīng)

6) StringWriter：無與之對應(yīng)的以字節(jié)為導(dǎo)向的stream

主要方法：

(1)public?void?write(int?c)?throws?IOException；//將整型值c的低16位寫入輸出流

(2)public?void?write(char?cbuf[])?throws?IOException；//將字符數(shù)組cbuf[]寫入輸出流

(3)public?abstract?void?write(char?cbuf[],int?off,int?len)?throws?IOException；//將字符數(shù)組cbuf[]中的從索引為off的位置處開始的len個字符寫入輸出流

(4)public?void?write(String?str)?throws?IOException；//將字符串str中的字符寫入輸出流

(5)public?void?write(String?str,int?off,int?len)?throws?IOException；//將字符串str?中從索引off開始處的len個字符寫入輸出流

(6)flush(?) //刷空輸出流，并輸出所有被緩存的字節(jié)。

(7)close()?關(guān)閉流public?abstract?void?close()?throws?IOException

3 .InputStream與Reader差別 OutputStream與Writer差別

InputStream和OutputStream類處理的是字節(jié)流，數(shù)據(jù)流中的最小單位是字節(jié)(8個bit)

Reader與Writer處理的是字符流，在處理字符流時涉及了字符編碼的轉(zhuǎn)換問題

importjava.io.*;

publicclassEncodeTest?{

privatestaticvoidreadBuff(byte[]?buff)throwsIOException?{

ByteArrayInputStream?in?=newByteArrayInputStream(buff);

intdata;

while((data=in.read())!=-1)???System.out.print(data+"??");

System.out.println();?????in.close();?????}

publicstaticvoidmain(String?args[])throwsIOException?{

System.out.println("內(nèi)存中采用unicode字符編碼：");

charc='好';

intlowBit=c&0xFF;inthighBit=(c&0xFF00)>>8;

System.out.println(""+lowBit+"???"+highBit);

String?s="好";

System.out.println("本地操作系統(tǒng)默認(rèn)字符編碼：");

readBuff(s.getBytes());

System.out.println("采用GBK字符編碼：");

readBuff(s.getBytes("GBK"));

System.out.println("采用UTF-8字符編碼：");

readBuff(s.getBytes("UTF-8"));??????}

}

Reader類能夠?qū)⑤斎肓髦胁捎闷渌幋a類型的字符轉(zhuǎn)換為Unicode字符，然后在內(nèi)存中為其分配內(nèi)存

Writer類能夠?qū)?nèi)存中的Unicode字符轉(zhuǎn)換為其他編碼類型的字符，再寫到輸出流中。

9. IOException異常類的子類

1.public class ?EOFException ：

非正常到達文件尾或輸入流尾時，拋出這種類型的異常。

2.public class FileNotFoundException：

當(dāng)文件找不到時，拋出的異常。

3.public class InterruptedIOException：

當(dāng)I/O操作被中斷時，拋出這種類型的異常。

總結(jié)

以上是生活随笔為你收集整理的java 输入流详解_java输入输出流详解的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。