1、基本的輸入流和輸出流
流是 Java 中最重要的基本概念之一。文件讀寫(xiě)、網(wǎng)絡(luò)收發(fā)、進(jìn)程通信，幾乎所有需要輸入輸出的地方，都要用到流。
流是做什么用的呢？就是做輸入輸出用的。為什么輸入輸出要用“流”這種方式呢？因?yàn)槌绦蜉斎胼敵龅幕締挝皇亲止?jié)，輸入就是獲取一串字節(jié)，輸出就是發(fā)送一串字節(jié)。但是很多情況下，程序不可能接收所有的字節(jié)之后再進(jìn)行處理，而是接收一點(diǎn)處理一點(diǎn)。比方你下載魔獸世界，不可能全部下載到內(nèi)存里再保存到硬盤(pán)上，而是下載一點(diǎn)就保存一點(diǎn)。這時(shí)，流這種方式就非常適合。
在 Java 中，每個(gè)流都是一個(gè)對(duì)象。流分為兩種：輸入流(InputStream)和輸出流(OutputStream)。對(duì)于輸入流，你只要從流當(dāng)中不停地把字節(jié)取出來(lái)就是了；而對(duì)于輸出流，你只要把準(zhǔn)備好的字節(jié)串傳給它就行。
流對(duì)象是怎么獲得的呢？不同的外部系統(tǒng)，獲取流的方式也不同。例如，文件讀寫(xiě)就要?jiǎng)?chuàng)建 FileInputStream/FileOutputStream 對(duì)象，而網(wǎng)絡(luò)通信是通過(guò) Socket 對(duì)象來(lái)獲取輸入輸出流的。一般來(lái)說(shuō)，如果一個(gè)類(lèi)有 getInputStream() 或 getOutputStream() 這樣的方法，就表明它是通過(guò)流對(duì)象來(lái)進(jìn)行輸入輸出的。
InputStream 是輸入流，下面是一個(gè)通過(guò) InputStream 讀取文件的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.io.FileNotFoundException; import java.util.Arrays; /** * 通過(guò)流讀取文件 */public class ReadFileDemo { // 程序入口 public static void main(String[] args) { String path = "c:/boot.ini"; File file = new File(path); // 創(chuàng)建輸入流 InputStream is; try { is = new FileInputStream(file); } catch (FileNotFoundException e) { System.err.println("文件 " + path + " 不存在。"); return; } // 開(kāi)始讀取 byte[] content = new byte[0]; // 保存讀取出來(lái)的文件內(nèi)容 byte[] buffer = new byte[10240]; // 定義緩存 try { int eachTime = is.read(buffer); // 第一次讀取。如果返回值為 -1 就表示沒(méi)有內(nèi)容可讀了。 while (eachTime != -1) { // 讀取出來(lái)的內(nèi)容放在 buffer 中，現(xiàn)在將其合并到 content。 content = concatByteArrays(content, buffer, eachTime); eachTime = is.read(buffer); // 繼續(xù)讀取 } } catch (IOException e) { System.err.println("讀取文件內(nèi)容失敗。"); e.printStackTrace(); } finally { try { is.close(); } catch (IOException e) { // 這里的異?？梢院雎圆惶幚? } } // 輸出文件內(nèi)容 String contentStr = new String(content); System.out.println(contentStr); } /** * 合并兩個(gè)字節(jié)串 * * @param bytes1 字節(jié)串1 * @param bytes2 字節(jié)串2 * @param sizeOfBytes2 需要從 bytes2 中取出的長(zhǎng)度 * * @return bytes1 和 bytes2 中的前 sizeOfBytes2 個(gè)字節(jié)合并后的結(jié)果 */ private static byte[] concatByteArrays(byte[] bytes1, byte[] bytes2, int sizeOfBytes2) { byte[] result = Arrays.copyOf(bytes1, (bytes1.length + sizeOfBytes2)); System.arraycopy(bytes2, 0, result, bytes1.length, sizeOfBytes2); return result; } } |
雖然寫(xiě)得很啰嗦，但這確實(shí)是 InputStream 的基本用法。注意，這只是一個(gè)例子，說(shuō)明如何從輸入流中讀取字節(jié)串。實(shí)際上，Java 提供更簡(jiǎn)單的方式來(lái)讀取文本文件。以后將會(huì)介紹。
相比從流中讀取，使用 OutputStream 輸出則是非常簡(jiǎn)單的事情。下面是一個(gè)例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import java.io.OutputStream; import java.io.FileOutputStream; import java.io.File; import java.io.IOException; import java.util.Date; /** * 將當(dāng)前日期保存到文件 */public class SaveFileDemo { public static void main(String[] args) throws IOException { String path = "c:/now.txt"; File file = new File(path); if (!file.exists() && !file.createNewFile()) { System.err.println("無(wú)法創(chuàng)建文件。"); return; } OutputStream os = new FileOutputStream(file); // 創(chuàng)建輸出流（前提是文件存在） os.write(new Date().toString().getBytes()); // 將當(dāng)前時(shí)間寫(xiě)入文件 os.close(); // 必須關(guān)閉流，內(nèi)容才會(huì)寫(xiě)入文件。 System.out.println("文件寫(xiě)入完成。"); } } |
Java 還提供其它的流操作方式，但它們都是對(duì) InputStream 和 OutputStream 進(jìn)行擴(kuò)展或包裝。所以這兩個(gè)類(lèi)是基礎(chǔ)，必須要理解它們的使用。
2、Reader 和 Writer
介紹了 InputStream 和 OutputStream，接下來(lái)介紹 Reader 和 Writer。這兩個(gè)類(lèi)其實(shí)就是將 InputStream 和 OutputStream 包裝了一下。不過(guò)它們處理的不是字節(jié)(byte)，而是字符(char)。如果一個(gè)流當(dāng)中的內(nèi)容都是文本，那么用 Reader/Writer 處理起來(lái)會(huì)簡(jiǎn)單些。下面是一個(gè)用 Reader 讀取文本文件的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
import java.io.FileReader; import java.io.IOException; import java.io.Reader; /** * 讀取文本文件 */public class ReadTextFileDemo { // 程序入口 public static void main(String[] args) { String path = "c:/boot.ini"; String content = ""; try { Reader reader = new FileReader(path); char[] buffer = new char[10240]; int count; while ((count = reader.read(buffer)) != -1) { content += new String(buffer, 0, count); } } catch (IOException e) { System.err.println("讀取文件失敗。"); e.printStackTrace(); } System.out.println(content); } } |
至于如何用 Writer 將文本內(nèi)容寫(xiě)入文件，這里就不給出例子了，看官自己試著寫(xiě)一下吧。
上面這個(gè)例子，仍然不是讀取文本文件最常用的方式。Java 提供 BufferedReader，我們通常用它來(lái)讀取文本文件。下面是一個(gè)例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; /** * 用 BufferedReader 讀取文本文件 */public class ReadTextDemo2 { public static void main(String[] args) { String path = "c:/boot.ini"; String content = ""; try { BufferedReader reader = new BufferedReader(new FileReader(path)); String line; while ((line = reader.readLine()) != null) { content += line + "/n"; } } catch (IOException e) { System.err.println("讀取文件失敗。"); e.printStackTrace(); } System.out.println(content); } } |
3、對(duì)象序列化
對(duì)象序列化也是流應(yīng)用的一個(gè)重要方面。序列化就是把一個(gè)對(duì)象轉(zhuǎn)換成一串字節(jié)，既可以保存起來(lái)，也可以傳給另外的 Java 程序使用。ObjectOutputStream 和 ObjectInputStream 就是專(zhuān)門(mén)用來(lái)進(jìn)行序列化和反序列化的。下面就是一個(gè)簡(jiǎn)單的例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
import java.io.ObjectOutputStream; import java.io.FileOutputStream; import java.io.File; import java.io.IOException; import java.io.Serializable; import java.io.ObjectInputStream; import java.io.FileInputStream; import java.io.EOFException; /** * ObjectOutputStream/ObjectInputStream 示例。 * 這兩個(gè)類(lèi)分別用于序列化和反序列化。 */public class SerializationDemo { public static void main(String[] args) throws Exception { String path = "c:/persons.data"; File f = new File(path); if (!f.exists()) { f.createNewFile(); } writePersons(path); readPersons(path); } // 從指定的文件中讀取 Person 對(duì)象 private static void readPersons(String path) throws IOException, ClassNotFoundException { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path)); Person p; while (true) { try { p = (Person) ois.readObject(); System.out.println(p); } catch (EOFException e) { break; } } } // 將 Person 對(duì)象保存到指定的文件中 private static void writePersons(String path) throws IOException { Person[] persons = new Person[]{ new Person("張三", 23), new Person("李四", 24) }; ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path)); for (Person person : persons) { oos.writeObject(person); } oos.close(); } /////////////////////////////////////////////////////////// private static class Person implements Serializable { private String name; private int age; public Person() { } public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person{" + "name='" + name + '/'' + ", age=" + age + '}'; } } } |
這個(gè)例子里面看不到字節(jié)和字符的讀寫(xiě)，因?yàn)檫@兩個(gè)類(lèi)都包裝好了。上面只是一個(gè)簡(jiǎn)單的例子，序列化要寫(xiě)好的話(huà)還是有不少講究的。想深入了解序列化，可以看看這里。本文只關(guān)注跟流有關(guān)的部分。其實(shí)序列化用的很少，因?yàn)樾蛄谢档土遂`活性，所以可以不用的話(huà)一般都不會(huì)用。
