Java語言的輸入輸出功能是十分強大而靈活的，美中不足的是看上去輸入輸出的代碼并不是很簡潔，因為你往往需要包裝許多不同的對象。在Java類庫中，IO部分的內(nèi)容是很龐大的，因為它涉及的領(lǐng)域很廣泛:標準輸入輸出，文件的操作，網(wǎng)絡(luò)上的數(shù)據(jù)流，字符串流，對象流，zip文件流....本文的目的是為大家做一個簡要的介紹。
流是一個很形象的概念，當程序需要讀取數(shù)據(jù)的時候，就會開啟一個通向數(shù)據(jù)源的流，這個數(shù)據(jù)源可以是文件，內(nèi)存，或是網(wǎng)絡(luò)連接。類似的，當程序需要寫入數(shù)據(jù)的時候，就會開啟一個通向目的地的流。這時候你就可以想象數(shù)據(jù)好像在這其中“流”動一樣，如下圖：
Java中的流分為兩種，一種是字節(jié)流，另一種是字符流，分別由四個抽象類來表示（每種流包括輸入和輸出兩種所以一共四個）:InputStream，OutputStream，Reader，Writer。Java中其他多種多樣變化的流均是由它們派生出來的:
在這其中InputStream和OutputStream在早期的Java版本中就已經(jīng)存在了，它們是基于字節(jié)流的，而基于字符流的Reader和Writer是后來加入作為補充的。以上的層次圖是Java類庫中的一個基本的層次體系，如果你感興趣想了解更多內(nèi)容的話，可以到Sun公司主頁獲取更多信息。
在這四個抽象類中，InputStream和Reader定義了完全相同的接口：
int read()
int read(char cbuf[])
int read(char cbuf[], int offset, int length) |
而OutputStream和Writer也是如此：
int write(int c)
int write(char cbuf[])
int write(char cbuf[], int offset, int length) |
這六個方法都是最基本的，read()和write()通過方法的重載來讀寫一個字節(jié)，或者一個字節(jié)數(shù)組。
更多靈活多變的功能是由它們的子類來擴充完成的。知道了Java輸入輸出的基本層次結(jié)構(gòu)以后，本文在這里想給大家一些以后可以反復應(yīng)用例子，對于所有子類的細節(jié)及其功能并不詳細討論。
public class IOStreamDemo {
public void samples() throws IOException {
//1. 這是從鍵盤讀入一行數(shù)據(jù),返回的是一個字符串
BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));
System.out.print("Enter a line:");
System.out.println(stdin.readLine());
//2. 這是從文件中逐行讀入數(shù)據(jù)
BufferedReader in = new BufferedReader(new FileReader("IOStreamDemo.java"));
String s, s2 = new String();
while((s = in.readLine())!= null)
s2 += s + "\n";
in.close();
//3. 這是從一個字符串中逐個讀入字節(jié)
StringReader in1 = new StringReader(s2);
int c;
while((c = in1.read()) != -1)
System.out.print((char)c);
//4. 這是將一個字符串寫入文件
try {
BufferedReader in2 = new BufferedReader(new StringReader(s2));
PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("IODemo.out")));
int lineCount = 1;
while((s = in2.readLine()) != null )
out1.println(lineCount++ + ": " + s);
out1.close();
} catch(EOFException e) {
System.err.println("End of stream");
}
}
} |
對于上面的例子，需要說明的有以下幾點：
1. BufferedReader是Reader的一個子類，它具有緩沖的作用，避免了頻繁的從物理設(shè)備中讀取信息。它有以下兩個構(gòu)造函數(shù)：
BufferedReader(Reader in)
BufferedReader(Reader in, int sz) |
這里的sz是指定緩沖區(qū)的大小。
它的基本方法：
void close() //關(guān)閉流
void mark(int readAheadLimit) //標記當前位置
boolean markSupported() //是否支持標記
int read() //繼承自Reader的基本方法
int read(char[] cbuf, int off, int len) //繼承自Reader的基本方法
String readLine() //讀取一行內(nèi)容并以字符串形式返回
boolean ready() //判斷流是否已經(jīng)做好讀入的準備
void reset() //重設(shè)到最近的一個標記
long skip(long n) //跳過指定個數(shù)的字符讀取 |
2. InputStreamReader是InputStream和Reader之間的橋梁，由于System.in是字節(jié)流，需要用它來包裝之后變?yōu)樽址鞴┙o BufferedReader使用。
3. PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("IODemo.out")));
這句話體現(xiàn)了Java輸入輸出系統(tǒng)的一個特點，為了達到某個目的，需要包裝好幾層。首先，輸出目的地是文件IODemo.out，所以最內(nèi)層包裝的是FileWriter，建立一個輸出文件流，接下來，我們希望這個流是緩沖的，所以用BufferedWriter來包裝它以達到目的，最后，我們需要格式化輸出結(jié)果，于是將PrintWriter包在最外層。
Java提供了這樣一個功能，將標準的輸入輸出流轉(zhuǎn)向，也就是說，我們可以將某個其他的流設(shè)為標準輸入或輸出流，看下面這個例子：
|
import java.io.*;
public class Redirecting {
public static void main(String[] args) throws IOException {
PrintStream console = System.out;
BufferedInputStream in = new BufferedInputStream( new FileInputStream( "Redirecting.java"));
PrintStream out = new PrintStream( new BufferedOutputStream( new FileOutputStream("test.out")));
System.setIn(in);
System.setOut(out);
BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
String s;
while((s = br.readLine()) != null)
System.out.println(s);
out.close();
System.setOut(console);
}
} |
在這里java.lang.System的靜態(tài)方法
static void setIn(InputStream in)
static void setOut(PrintStream out) |
提供了重新定義標準輸入輸出流的方法，這樣做是很方便的，比如一個程序的結(jié)果有很多，有時候甚至要翻頁顯示，這樣不便于觀看結(jié)果，這是你就可以將標準輸出流定義為一個文件流，程序運行完之后打開相應(yīng)的文件觀看結(jié)果，就直觀了許多。
Java流有著另一個重要的用途，那就是利用對象流對對象進行序列化。下面將開始介紹這方面的問題。
在一個程序運行的時候，其中的變量數(shù)據(jù)是保存在內(nèi)存中的，一旦程序結(jié)束這些數(shù)據(jù)將不會被保存，一種解決的辦法是將數(shù)據(jù)寫入文件，而Java中提供了一種機制，它可以將程序中的對象寫入文件，之后再從文件中把對象讀出來重新建立。這就是所謂的對象序列化Java中引入它主要是為了RMI（Remote Method Invocation）和Java Bean所用，不過在平時應(yīng)用中，它也是很有用的一種技術(shù)。
所有需要實現(xiàn)對象序列化的對象必須首先實現(xiàn)Serializable接口。下面看一個例子：
|
import java.io.*;
import java.util.*;
public class Logon implements Serializable {
private Date date = new Date();
private String username;
private transient String password;
Logon(String name, String pwd) {
username = name;
password = pwd;
}
public String toString() {
String pwd = (password == null) ? "(n/a)" : password;
return "logon info: \n " + "username: " + username + "\n date: " + date + "\n password: " + pwd;
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
Logon a = new Logon("Morgan", "morgan83");
System.out.println( "logon a = " + a);
ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));
o.writeObject(a);
o.close();
int seconds = 5;
long t = System.currentTimeMillis() + seconds * 1000;
while(System.currentTimeMillis() < t) ;
ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.out"));
System.out.println( "Recovering object at " + new Date());
a = (Logon)in.readObject();
System.out.println("logon a = " + a);
}
} |
類Logon是一個記錄登錄信息的類，包括用戶名和密碼。首先它實現(xiàn)了接口Serializable，這就標志著它可以被序列化。之后再main方法里ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.out"));新建一個對象輸出流包裝一個文件流，表示對象序列化的目的地是文件Logon.out。然后用方法writeObject開始寫入。想要還原的時候也很簡單ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.out"));新建一個對象輸入流以文件流Logon.out為參數(shù)，之后調(diào)用readObject方法就可以了。
需要說明一點，對象序列化有一個神奇之處就是，它建立了一張對象網(wǎng)，將當前要序列化的對象中所持有的引用指向的對象都包含起來一起寫入到文件，更為奇妙的是，如果你一次序列化了好幾個對象，它們中相同的內(nèi)容將會被共享寫入。這的確是一個非常好的機制。它可以用來實現(xiàn)深層拷貝，有關(guān)深層拷貝的問題在JavaWorld上有一篇文章做了幾種實現(xiàn)方法的介紹和比較，有興趣者可以去看看。
關(guān)鍵字transient在這里表示當前內(nèi)容將不被序列化，比如例子中的密碼，需要保密，所以沒有被寫入文件。
對Java的輸入輸出功能，就淺淺的介紹到這里，本文的目的只是開一個好頭，希望能讓大家對Java輸入輸出流有個基本的認識，更多更為全面的信息在http://java.sun.com有權(quán)威的說明。