原文地址：http://www.cnblogs.com/xdp-gacl/p/3634409.html
一、JAVA流式輸入/輸出原理
流是用來讀寫數(shù)據(jù)的，java有一個類叫File，它封裝的是文件的文件名，只是內(nèi)存里面的一個對象，真正的文件是在硬盤上的一塊空間，在這個文件里面存放著各種各樣的數(shù)據(jù)，我們想讀文件里面的數(shù)據(jù)怎么辦呢？是通過一個流的方式來讀，咱們要想從程序讀數(shù)據(jù)，對于計算機(jī)來說，無論讀什么類型的數(shù)據(jù)都是以010101101010這樣的形式讀取的。怎么把文件里面的數(shù)據(jù)讀出來呢？你可以把文件想象成一個小桶，文件就是一個桶，文件里面的數(shù)據(jù)就相當(dāng)于是這個桶里面的水，那么我們怎么從這個桶里面取水呢，也就是怎么從這個文件讀取數(shù)據(jù)呢。
常見的取水的辦法是我們用一根管道插到桶上面，然后在管道的另一邊打開水龍頭，桶里面的水就開始嘩啦嘩啦地從水龍頭里流出來了，桶里面的水是通過這根管道流出來的，因此這根管道就叫流，JAVA里面的流式輸入/輸出跟水流的原理一模一樣，當(dāng)你要從文件讀取數(shù)據(jù)的時候，一根管道插到文件里面去，然后文件里面的數(shù)據(jù)就順著管道流出來，這時你在管道的另一頭就可以讀取到從文件流出來的各種各樣的數(shù)據(jù)了。當(dāng)你要往文件寫入數(shù)據(jù)時，也是通過一根管道，讓要寫入的數(shù)據(jù)通過這根管道嘩啦嘩啦地流進(jìn)文件里面去。除了從文件去取數(shù)據(jù)以外，還可以通過網(wǎng)絡(luò)，比如用一根管道把我和你的機(jī)子連接起來，我說一句話，通過這個管道流進(jìn)你的機(jī)子里面，你馬上就可以看得到，而你說一句話，通過這根管道流到我的機(jī)子里面，我也馬上就可以看到。有的時候，一根管道不夠用，比方說這根管道流過來的水有一些雜質(zhì)，我們就可以在這個根管道的外面再包一層管道，把雜質(zhì)給過濾掉。從程序的角度來講，從計算機(jī)讀取到的原始數(shù)據(jù)肯定都是010101這種形式的，一個字節(jié)一個字節(jié)地往外讀，當(dāng)你這樣讀的時候你覺得這樣的方法不合適，沒關(guān)系，你再在這根管道的外面再包一層比較強大的管道，這個管道可以把010101幫你轉(zhuǎn)換成字符串。這樣你使用程序讀取數(shù)據(jù)時讀到的就不再是010101這種形式的數(shù)據(jù)了，而是一些可以看得懂的字符串了。
流是用來讀寫數(shù)據(jù)的，java有一個類叫File，它封裝的是文件的文件名，只是內(nèi)存里面的一個對象，真正的文件是在硬盤上的一塊空間，在這個文件里面存放著各種各樣的數(shù)據(jù)，我們想讀文件里面的數(shù)據(jù)怎么辦呢？是通過一個流的方式來讀，咱們要想從程序讀數(shù)據(jù)，對于計算機(jī)來說，無論讀什么類型的數(shù)據(jù)都是以010101101010這樣的形式讀取的。怎么把文件里面的數(shù)據(jù)讀出來呢？你可以把文件想象成一個小桶，文件就是一個桶，文件里面的數(shù)據(jù)就相當(dāng)于是這個桶里面的水，那么我們怎么從這個桶里面取水呢，也就是怎么從這個文件讀取數(shù)據(jù)呢。
常見的取水的辦法是我們用一根管道插到桶上面，然后在管道的另一邊打開水龍頭，桶里面的水就開始嘩啦嘩啦地從水龍頭里流出來了，桶里面的水是通過這根管道流出來的，因此這根管道就叫流，JAVA里面的流式輸入/輸出跟水流的原理一模一樣，當(dāng)你要從文件讀取數(shù)據(jù)的時候，一根管道插到文件里面去，然后文件里面的數(shù)據(jù)就順著管道流出來，這時你在管道的另一頭就可以讀取到從文件流出來的各種各樣的數(shù)據(jù)了。當(dāng)你要往文件寫入數(shù)據(jù)時，也是通過一根管道，讓要寫入的數(shù)據(jù)通過這根管道嘩啦嘩啦地流進(jìn)文件里面去。除了從文件去取數(shù)據(jù)以外，還可以通過網(wǎng)絡(luò)，比如用一根管道把我和你的機(jī)子連接起來，我說一句話，通過這個管道流進(jìn)你的機(jī)子里面，你馬上就可以看得到，而你說一句話，通過這根管道流到我的機(jī)子里面，我也馬上就可以看到。有的時候，一根管道不夠用，比方說這根管道流過來的水有一些雜質(zhì)，我們就可以在這個根管道的外面再包一層管道，把雜質(zhì)給過濾掉。從程序的角度來講，從計算機(jī)讀取到的原始數(shù)據(jù)肯定都是010101這種形式的，一個字節(jié)一個字節(jié)地往外讀，當(dāng)你這樣讀的時候你覺得這樣的方法不合適，沒關(guān)系，你再在這根管道的外面再包一層比較強大的管道，這個管道可以把010101幫你轉(zhuǎn)換成字符串。這樣你使用程序讀取數(shù)據(jù)時讀到的就不再是010101這種形式的數(shù)據(jù)了，而是一些可以看得懂的字符串了。
二、輸入輸出流分類
io包里面定義了所有的流，所以一說流指的就是io包里面的
什么叫輸入流？什么叫輸出流？用一根管道一端插進(jìn)文件里程序里面，然后開始讀數(shù)據(jù)，那么這是輸入還是輸出呢？如果站在文件的角度上，這叫輸出，如果站在程序的角度上，這叫輸入。
記住，以后說輸入流和輸出流都是站在程序的角度上來說。
三、節(jié)點流和處理流
你要是對原始的流不滿意，你可以在這根管道外面再套其它的管道，套在其它管道之上的流叫處理流。為什么需要處理流呢？這就跟水流里面有雜質(zhì)，你要過濾它，你可以再套一層管道過濾這些雜質(zhì)一樣。
流里面有雜質(zhì)，你要過濾它，你可以再套一層管道過濾這些雜質(zhì)一樣。
3.1.節(jié)點流類型
節(jié)點流就是一根管道直接插到數(shù)據(jù)源上面，直接讀數(shù)據(jù)源里面的數(shù)據(jù)，或者是直接往數(shù)據(jù)源里面寫入數(shù)據(jù)。典型的節(jié)點流是文件流：文件的字節(jié)輸入流（FileInputStream），文件的字節(jié)輸出流（FileOutputStream），文件的字符輸入流（FileReader），文件的字符輸出流（FileWriter）。
3.2.處理流類型
處理流是包在別的流上面的流，相當(dāng)于是包到別的管道上面的管道。
四、InputStream(輸入流)
我們看到的具體的某一些管道，凡是以InputStream結(jié)尾的管道，都是以字節(jié)的形式向我們的程序輸入數(shù)據(jù)。
4.1.InputStream的基本方法
read()方法是一個字節(jié)一個字節(jié)地往外讀，每讀取一個字節(jié)，就處理一個字節(jié)。read(byte[] buffer)方法讀取數(shù)據(jù)時，先把讀取到的數(shù)據(jù)填滿這個byte[]類型的數(shù)組buffer(buffer是內(nèi)存里面的一塊緩沖區(qū))，然后再處理數(shù)組里面的數(shù)據(jù)。這就跟我們?nèi)∷粯樱扔靡粋€桶去接，等桶接滿水后再處理桶里面的水。如果是每讀取一個字節(jié)就處理一個字節(jié)，這樣子讀取也太累了。
五、OutputStream(輸出流)
5.1.OutputStream的基本方法
六、Reader流
6.1.Reader的基本方法
七、Writer流
7.1.Writer的基本方法
八、節(jié)點流講解
以File(文件)這個類型作為講解節(jié)點流的典型代表
- 范例：使用FileInputStream流來讀取FileInputStream.java文件的內(nèi)容
public class TestFileInputStream {
public static void main(String args[]) {
int b = 0;// 使用變量b來裝調(diào)用read()方法時返回的整數(shù)
FileInputStream in = null;
// 使用FileInputStream流來讀取有中文的內(nèi)容時，讀出來的是亂碼，因為使用InputStream流里面的read()方法讀取內(nèi)容時是一個字節(jié)一個字節(jié)地讀取的，而一個漢字是占用兩個字節(jié)的，所以讀取出來的漢字無法正確顯示。
// FileReader in = null;//使用FileReader流來讀取內(nèi)容時，中英文都可以正確顯示，因為Reader流里面的read()方法是一個字符一個字符地讀取的，這樣每次讀取出來的都是一個完整的漢字，這樣就可以正確顯示了。
try {
in = new FileInputStream("D:\\Java\\MyEclipse 10\\Workspaces\\AnnotationTest\\src\\cn\\galc\\test\\FileInputStream.java");
// in = new FileReader("D:/java/io/TestFileInputStream.java");
} catch (FileNotFoundException e) {
System.out.println("系統(tǒng)找不到指定文件！");
System.exit(-1);// 系統(tǒng)非正常退出
}
long num = 0;// 使用變量num來記錄讀取到的字符數(shù)
try {// 調(diào)用read()方法時會拋異常，所以需要捕獲異常
while ((b = in.read()) != -1) {
// 調(diào)用int read() throws Exception方法時，返回的是一個int類型的整數(shù)
// 循環(huán)結(jié)束的條件就是返回一個值-1，表示此時已經(jīng)讀取到文件的末尾了。
// System.out.print(b+"\t");//如果沒有使用“(char)b”進(jìn)行轉(zhuǎn)換，那么直接打印出來的b就是數(shù)字，而不是英文和中文了
System.out.print((char) b);
// “char(b)”把使用數(shù)字表示的漢字和英文字母轉(zhuǎn)換成字符輸入
num++;
}
in.close();// 關(guān)閉輸入流
System.out.println();
System.out.println("總共讀取了" + num + "個字節(jié)的文件");
} catch (IOException e1) {
System.out.println("文件讀取錯誤！");
}
}
}
- 范例：使用FileOutputStream流往一個文件里面寫入數(shù)據(jù)
public class TestFileOutputStream {
public static void main(String args[]) {
int b = 0;
FileInputStream in = null;
FileOutputStream out = null;
try {
in = new FileInputStream("D:\\Java\\MyEclipse 10\\Workspaces\\AnnotationTest\\src\\cn\\galc\\test\\MyMouseAdapter.java");
out = new FileOutputStream("D:/java/TestFileOutputStream1.java");
// 指明要寫入數(shù)據(jù)的文件，如果指定的路徑中不存在TestFileOutputStream1.java這樣的文件，則系統(tǒng)會自動創(chuàng)建一個
while ((b = in.read()) != -1) {
out.write(b);
// 調(diào)用write(int c)方法把讀取到的字符全部寫入到指定文件中去
}
in.close();
out.close();
} catch (FileNotFoundException e) {
System.out.println("文件讀取失敗");
System.exit(-1);// 非正常退出
} catch (IOException e1) {
System.out.println("文件復(fù)制失敗！");
System.exit(-1);
}
System.out
.println("TestFileInputStream.java文件里面的內(nèi)容已經(jīng)成功復(fù)制到文件TestFileOutStream1.java里面");
}
}
FileInputStream和FileOutputStream這兩個流都是字節(jié)流，都是以一個字節(jié)為單位進(jìn)行輸入和輸出的。所以對于占用2個字節(jié)存儲空間的字符來說讀取出來時就會顯示成亂碼。
- 范例：使用FileWriter（字符流）向指定文件中寫入數(shù)據(jù)
/*使用FileWriter（字符流）向指定文件中寫入數(shù)據(jù)
寫入數(shù)據(jù)時以1個字符為單位進(jìn)行寫入*/
public class TestFileWriter{
public static void main(String args[]){
/*使用FileWriter輸出流從程序把數(shù)據(jù)寫入到Uicode.dat文件中
使用FileWriter流向文件寫入數(shù)據(jù)時是一個字符一個字符寫入的*/
FileWriter fw = null;
try{
fw = new FileWriter("D:/java/Uicode.dat");
//字符的本質(zhì)是一個無符號的16位整數(shù)
//字符在計算機(jī)內(nèi)部占用2個字節(jié)
//這里使用for循環(huán)把0～60000里面的所有整數(shù)都輸出
//這里相當(dāng)于是把全世界各個國家的文字都0～60000內(nèi)的整數(shù)的形式來表示
for(int c=0;c<=60000;c++){
fw.write(c);
//使用write(int c)把0～60000內(nèi)的整數(shù)寫入到指定文件內(nèi)
//調(diào)用write()方法時，我認(rèn)為在執(zhí)行的過程中應(yīng)該使用了“(char)c”進(jìn)行強制轉(zhuǎn)換，即把整數(shù)轉(zhuǎn)換成字符來顯示
//因為打開寫入數(shù)據(jù)的文件可以看到，里面顯示的數(shù)據(jù)并不是0～60000內(nèi)的整數(shù)，而是不同國家的文字的表示方式
}
/*使用FileReader(字符流)讀取指定文件里面的內(nèi)容
讀取內(nèi)容時是以一個字符為單位進(jìn)行讀取的*/
int b = 0;
long num = 0;
FileReader fr = null;
fr = new FileReader("D:/java/Uicode.dat");
while((b = fr.read())!= -1){
System.out.print((char)b + "\t");
num++;
}
System.out.println();
System.out.println("總共讀取了"+num+"個字符");
}catch(Exception e){
e.printStackTrace();
}
}
}
FileReader和FileWriter這兩個流都是字符流，都是以一個字符為單位進(jìn)行輸入和輸出的。所以讀取和寫入占用2個字節(jié)的字符時都可以正常地顯示出來，以上是以File(文件)這個類型為例對節(jié)點流進(jìn)行了講解，所謂的節(jié)點流指定就是直接把輸入流或輸出插入到數(shù)據(jù)源上，直接往數(shù)據(jù)源里面寫入數(shù)據(jù)或讀取數(shù)據(jù)。
九、處理流講解
9.1.第一種處理流——緩沖流(Buffering)
帶有緩沖區(qū)的，緩沖區(qū)(Buffer)就是內(nèi)存里面的一小塊區(qū)域，讀寫數(shù)據(jù)時都是先把數(shù)據(jù)放到這塊緩沖區(qū)域里面，減少io對硬盤的訪問次數(shù)，保護(hù)我們的硬盤。可以把緩沖區(qū)想象成一個小桶，把要讀寫的數(shù)據(jù)想象成水，每次讀取數(shù)據(jù)或者是寫入數(shù)據(jù)之前，都是先把數(shù)據(jù)裝到這個桶里面，裝滿了以后再做處理。這就是所謂的緩沖。先把數(shù)據(jù)放置到緩沖區(qū)上，等到緩沖區(qū)滿了以后，再一次把緩沖區(qū)里面的數(shù)據(jù)寫入到硬盤上或者讀取出來，這樣可以有效地減少對硬盤的訪問次數(shù)，有利于保護(hù)我們的硬盤。
- 緩沖流測試代碼：
public class TestBufferStream {
public static void main(String args[]) {
FileInputStream fis = null;
try {
fis = new FileInputStream("D:/java/TestFileInputStream.java");
// 在FileInputStream節(jié)點流的外面套接一層處理流BufferedInputStream
BufferedInputStream bis = new BufferedInputStream(fis);
int c = 0;
System.out.println((char) bis.read());
System.out.println((char) bis.read());
bis.mark(100);// 在第100個字符處做一個標(biāo)記
for (int i = 0; i <= 10 && (c = bis.read()) != -1; i++) {
System.out.print((char) c);
}
System.out.println();
bis.reset();// 重新回到原來標(biāo)記的地方
for (int i = 0; i <= 10 && (c = bis.read()) != -1; i++) {
System.out.print((char) c);
}
bis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
public class TestBufferStream1{
public static void main(String args[]){
try{
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\java\\dat.txt"));
//在節(jié)點流FileWriter的外面再套一層處理流BufferedWriter
String s = null;
for(int i=0;i<100;i++){
s = String.valueOf(Math.random());//“Math.random()”將會生成一系列介于0～1之間的隨機(jī)數(shù)。
// static String valueOf(double d)這個valueOf()方法的作用就是把一個double類型的數(shù)轉(zhuǎn)換成字符串
//valueOf()是一個靜態(tài)方法，所以可以使用“類型.靜態(tài)方法名”的形式來調(diào)用
bw.write(s);//把隨機(jī)數(shù)字符串寫入到指定文件中
bw.newLine();//調(diào)用newLine()方法使得每寫入一個隨機(jī)數(shù)就換行顯示
}
bw.flush();//調(diào)用flush()方法清空緩沖區(qū)
BufferedReader br = new BufferedReader(new FileReader("D:/java/dat.txt"));
//在節(jié)點流FileReader的外面再套一層處理流BufferedReader
while((s = br.readLine())!=null){
//使用BufferedReader處理流里面提供String readLine()方法讀取文件中的數(shù)據(jù)時是一行一行讀取的
//循環(huán)結(jié)束的條件就是使用readLine()方法讀取數(shù)據(jù)返回的字符串為空值后則表示已經(jīng)讀取到文件的末尾了。
System.out.println(s);
}
bw.close();
br.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
程序的輸入指的是把從文件讀取到的內(nèi)容存儲到為程序分配的內(nèi)存區(qū)域里面去。流，什么是流，流無非就是兩根管道，一根向里，一根向外，向里向外都是對于我們自己寫的程序來說，流分為各種各樣的類型，不同的分類方式又可以分為不同的類型，根據(jù)方向來分，分為輸入流和輸出流，根據(jù)讀取數(shù)據(jù)的單位的不同，又可以分為字符流和字節(jié)流，除此之外，還可以分為節(jié)點流和處理流，節(jié)點流就是直接和數(shù)據(jù)源連接的流，處理流就是包在其它流上面的流，處理流不是直接和數(shù)據(jù)源連接，而是從數(shù)據(jù)源讀取到數(shù)據(jù)以后再通過處理流處理一遍。緩沖流也包含了四個類：BufferedInputStream、BufferedOutputStream、BufferedReader和BufferedWriter。流都是成對的，沒有流是是不成對的，肯定是一個in，一個out。
9.2.第二種處理流——轉(zhuǎn)換流
轉(zhuǎn)換流非常的有用，它可以把一個字節(jié)流轉(zhuǎn)換成一個字符流，轉(zhuǎn)換流有兩種，一種叫InputStreamReader，另一種叫OutputStreamWriter。InputStream是字節(jié)流，Reader是字符流，InputStreamReader就是把InputStream轉(zhuǎn)換成Reader。OutputStream是字節(jié)流，Writer是字符流，OutputStreamWriter就是把OutputStream轉(zhuǎn)換成Writer。把OutputStream轉(zhuǎn)換成Writer之后就可以一個字符一個字符地通過管道寫入數(shù)據(jù)了，而且還可以寫入字符串。我們?nèi)绻靡粋€FileOutputStream流往文件里面寫東西，得要一個字節(jié)一個字節(jié)地寫進(jìn)去，但是如果我們在FileOutputStream流上面套上一個字符轉(zhuǎn)換流，那我們就可以一個字符串一個字符串地寫進(jìn)去。
轉(zhuǎn)換流測試代碼：
public class TestTransform1 {
public static void main(String args[]) {
try {
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream("D:/java/char.txt"));
osw.write("MircosoftsunIBMOracleApplet");// 把字符串寫入到指定的文件中去
System.out.println(osw.getEncoding());// 使用getEncoding()方法取得當(dāng)前系統(tǒng)的默認(rèn)字符編碼
osw.close();
osw = new OutputStreamWriter(new FileOutputStream(
"D:\\java\\char.txt", true), "ISO8859_1");
// 如果在調(diào)用FileOutputStream的構(gòu)造方法時沒有加入true，那么新加入的字符串就會替換掉原來寫入的字符串，在調(diào)用構(gòu)造方法時指定了字符的編碼
osw.write("MircosoftsunIBMOracleApplet");// 再次向指定的文件寫入字符串，新寫入的字符串加入到原來字符串的后面
System.out.println(osw.getEncoding());
osw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
import java.io.*;
public class TestTransform2{
public static void main(String args[]){
try{
InputStreamReader isr = new InputStreamReader(System.in);
//System.in這里的in是一個標(biāo)準(zhǔn)的輸入流，用來接收從鍵盤輸入的數(shù)據(jù)
BufferedReader br = new BufferedReader(isr);
String s = null;
s = br.readLine();//使用readLine()方法把讀取到的一行字符串保存到字符串變量s中去
while(s != null){
System.out.println(s.toUpperCase());//把保存在內(nèi)存s中的字符串打印出來
s = br.readLine();//在循環(huán)體內(nèi)繼續(xù)接收從鍵盤的輸入
if(s.equalsIgnoreCase("exit")){
//只要輸入exit循環(huán)就結(jié)束，就會退出
break;
}
}
}catch(Exception e){
e.printStackTrace();
}
}
}
9.3.第三種處理流——數(shù)據(jù)流
數(shù)據(jù)流測試代碼：
public class TestDataStream{
public static void main(String args[]){
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//在調(diào)用構(gòu)造方法時，首先會在內(nèi)存里面創(chuàng)建一個ByteArray字節(jié)數(shù)組
DataOutputStream dos = new DataOutputStream(baos);
//在輸出流的外面套上一層數(shù)據(jù)流，用來處理int，double類型的數(shù)
try{
dos.writeDouble(Math.random());//把產(chǎn)生的隨機(jī)數(shù)直接寫入到字節(jié)數(shù)組ByteArray中
dos.writeBoolean(true);//布爾類型的數(shù)據(jù)在內(nèi)存中就只占一個字節(jié)
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
System.out.println(bais.available());
DataInputStream dis = new DataInputStream(bais);
System.out.println(dis.readDouble());//先寫進(jìn)去的就先讀出來，調(diào)用readDouble()方法讀取出寫入的隨機(jī)數(shù)
System.out.println(dis.readBoolean());//后寫進(jìn)去的就后讀出來，這里面的讀取順序不能更改位置，否則會打印出不正確的結(jié)果
dos.close();
bais.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
通過bais這個流往外讀取數(shù)據(jù)的時候，是一個字節(jié)一個字節(jié)地往外讀取的，因此讀出來的數(shù)據(jù)無法判斷是字符串還是bool類型的值，因此要在它的外面再套一個流，通過dataInputStream把讀出來的數(shù)據(jù)轉(zhuǎn)換就可以判斷了。注意了：讀取數(shù)據(jù)的時候是先寫進(jìn)去的就先讀出來，因此讀ByteArray字節(jié)數(shù)組數(shù)據(jù)的順序應(yīng)該是先把占8個字節(jié)的double類型的數(shù)讀出來，然后再讀那個只占一個字節(jié)的boolean類型的數(shù)，因為double類型的數(shù)是先寫進(jìn)數(shù)組里面的，讀的時候也要先讀它。這就是所謂的先寫的要先讀。如果先讀Boolean類型的那個數(shù)，那么讀出來的情況可能就是把double類型數(shù)的8個字節(jié)里面的一個字節(jié)讀了出來。
9.4.打印流——Print
測試代碼：
/*這個小程序是重新設(shè)置打印輸出的窗口，
* 把默認(rèn)在命令行窗口輸出打印內(nèi)容設(shè)置成其他指定的打印顯示窗口
*/
import java.io.*;
public class TestPrintStream{
public static void main(String args[]){
PrintStream ps = null;
try{
FileOutputStream fos = new FileOutputStream("D:/java/log.txt");
ps = new PrintStream(fos);//在輸出流的外面套接一層打印流，用來控制打印輸出
if(ps != null){
System.setOut(ps);//這里調(diào)用setOut()方法改變了輸出窗口，以前寫System.out.print()默認(rèn)的輸出窗口就是命令行窗口.
//但現(xiàn)在使用System.setOut(ps)將打印輸出窗口改成了由ps指定的文件里面，通過這樣設(shè)置以后，打印輸出時都會在指定的文件內(nèi)打印輸出
//在這里將打印輸出窗口設(shè)置到了log.txt這個文件里面，所以打印出來的內(nèi)容會在log.txt這個文件里面看到
}
for(char c=0;c<=60000;c++){
System.out.print(c+"\t");//把世界各國的文字打印到log.txt這個文件中去
}
}catch(Exception e){
e.printStackTrace();
}
}
}
9.5. 對象流——Object
測試代碼：
public class TestObjectIo {
public static void main(String args[]) {
T t = new T();
t.k = 8;// 把k的值修改為8
try {
FileOutputStream fos = new FileOutputStream(
"D:/java/TestObjectIo.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
// ObjectOutputStream流專門用來處理Object的，在fos流的外面套接ObjectOutputStream流就可以直接把一個Object寫進(jìn)去
oos.writeObject(t);// 直接把一個t對象寫入到指定的文件里面
oos.flush();
oos.close();
FileInputStream fis = new FileInputStream(
"D:/java/TestObjectIo.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
// ObjectInputStream專門用來讀一個Object的
T tRead = (T) ois.readObject();
// 直接把文件里面的內(nèi)容全部讀取出來然后分解成一個Object對象，并使用強制轉(zhuǎn)換成指定類型T
System.out.print(tRead.i + "\t" + tRead.j + "\t" + tRead.d + "\t"
+ tRead.k);
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/*
* 凡是要將一個類的對象序列化成一個字節(jié)流就必須實現(xiàn)Serializable接口
* Serializable接口中沒有定義方法，Serializable接口是一個標(biāo)記性接口，用來給類作標(biāo)記，只是起到一個標(biāo)記作用。
* 這個標(biāo)記是給編譯器看的，編譯器看到這個標(biāo)記之后就可以知道這個類可以被序列化 如果想把某個類的對象序列化，就必須得實現(xiàn)Serializable接口
*/
class T implements Serializable {
// Serializable的意思是可以被序列化的
int i = 10;
int j = 9;
double d = 2.3;
int k = 15;
// transient int k = 15;
// 在聲明變量時如果加上transient關(guān)鍵字，那么這個變量就會被當(dāng)作是透明的，即不存在。
}
直接實現(xiàn)Serializable接口的類是JDK自動把這個類的對象序列化，而如果實現(xiàn)public interface Externalizable extends Serializable的類則可以自己控制對象的序列化，建議能讓JDK自己控制序列化的就不要讓自己去控制。
十、IO流總結(jié)
項目地址：傳送門
