寫在前面：本文章基本覆蓋了java IO的全部內容，java新IO沒有涉及，因爲我想和這個分開，以突出那個的重要性，新IO哪一篇文章還沒有開始寫，估計很快就能和大家見面。照舊，文章依舊以例子爲主，因爲講解內容的java書很多了，我覺的學以致用纔是真。代碼是寫出來的，不是看出來的。
最後歡迎大家提出意見和建議。
【案例1】創建一個新文件
|
1
2
3
4
5
6
7
8
9
10
11
|
import java.io.*;class hello{ public static void
main(String[] args) { File f=new File("D:\\hello.txt"); try{ f.createNewFile(); }catch (Exception e) { e.printStackTrace(); } }} |
【運行結果】：
程序運行之後，在d盤下會有一個名字爲hello.txt的文件。
【案例2】File類的兩個常量
|
1
2
3
4
5
6
7
|
import java.io.*;class hello{ public static void
main(String[] args) { System.out.println(File.separator); System.out.println(File.pathSeparator); }} |
【運行結果】：
\
;
此處多說幾句：有些同學可能認爲，我直接在windows下使用\進行分割不行嗎？當然是可以的。但是在linux下就不是\了。所以，要想使得我們的代碼跨平臺，更加健壯，所以，大家都採用這兩個常量吧，其實也多寫不了幾行。呵呵、
現在我們使用File類中的常量改寫上面的代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
import java.io.*;class hello{ public static void
main(String[] args) { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); try{ f.createNewFile(); }catch (Exception e) { e.printStackTrace(); } }} |
你看，沒有多寫多少吧，呵呵。所以建議使用File類中的常量。
刪除一個文件
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/** * 刪除一個文件 * */import java.io.*;class hello{ public static void
main(String[] args) { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); if(f.exists()){ f.delete(); }else{ System.out.println("文件不存在"); } }} |
創建一個文件夾
|
1
2
3
4
5
6
7
8
9
10
11
|
/** * 創建一個文件夾 * */import java.io.*;class hello{ public static void
main(String[] args) { String fileName="D:"+File.separator+"hello"; File f=new File(fileName); f.mkdir(); }} |
【運行結果】：
D盤下多了一個hello文件夾
列出指定目錄的全部文件（包括隱藏文件）：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
/** * 使用list列出指定目錄的全部文件 * */import java.io.*;class hello{ public static void
main(String[] args) { String fileName="D:"+File.separator; File f=new File(fileName); String[] str=f.list(); for (int i =
0; i < str.length; i++) { System.out.println(str[i]); } }} |
【運行結果】：
$RECYCLE.BIN
360
360Downloads
360Rec
360SoftMove
Config.Msi
da
Downloads
DriversBackup
eclipse
java web整合開發和項目實戰
Lenovo
MSOCache
Program
Program Files
python
RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}
System Volume Information
Tomcat6
var
vod_cache_data
新建文件夾
（你的運行結果應該和這個不一樣的，呵呵）
但是使用list返回的是String數組，。而且列出的不是完整路徑，如果想列出完整路徑的話，需要使用listFiles.他返回的是File的數組
列出指定目錄的全部文件（包括隱藏文件）：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/** * 使用listFiles列出指定目錄的全部文件 * listFiles輸出的是完整路徑 * */import java.io.*;class hello{ public static void
main(String[] args) { String fileName="D:"+File.separator; File f=new File(fileName); File[] str=f.listFiles(); for (int i =
0; i < str.length; i++) { System.out.println(str[i]); } }} |
【運行結果】：
D:\$RECYCLE.BIN
D:\360
D:\360Downloads
D:\360Rec
D:\360SoftMove
D:\Config.Msi
D:\da
D:\Downloads
D:\DriversBackup
D:\eclipse
D:\java web整合開發和項目實戰
D:\Lenovo
D:\MSOCache
D:\Program
D:\Program Files
D:\python
D:\RECYGLER.{8F92DA15-A229-A4D5-B5CE-5280C8B89C19}
D:\System Volume Information
D:\Tomcat6
D:\var
D:\vod_cache_data
D:\新建文件夾
通過比較可以指定，使用listFiles更加方便、
判斷一個指定的路徑是否爲目錄
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/** * 使用isDirectory判斷一個指定的路徑是否爲目錄 * */import java.io.*;class hello{ public static void
main(String[] args) { String fileName="D:"+File.separator; File f=new File(fileName); if(f.isDirectory()){ System.out.println("YES"); }else{ System.out.println("NO"); } }} |
【運行結果】：YES
搜索指定目錄的全部內容
|
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.*;class hello{ public static void
main(String[] args) { String fileName="D:"+File.separator; File f=new File(fileName); print(f); } public static void
print(File f){ if(f!=null){ if(f.isDirectory()){ File[] fileArray=f.listFiles(); if(fileArray!=null){ for (int
i = 0; i < fileArray.length; i++) { //遞歸調用 print(fileArray[i]); } } } else{ System.out.println(f); } } }} |
【運行結果】：
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\framepages\web4welcome_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\transit_jsp.class
……
【使用RandomAccessFile寫入文件】
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/** * 使用RandomAccessFile寫入文件 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); RandomAccessFile demo=new
RandomAccessFile(f,"rw"); demo.writeBytes("asdsad"); demo.writeInt(12); demo.writeBoolean(true); demo.writeChar('A'); demo.writeFloat(1.21f); demo.writeDouble(12.123); demo.close(); }} |
如果你此時打開hello。txt查看的話，會發現那是亂碼。
字節流
【向文件中寫入字符串】
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/** * 字節流 * 向文件中寫入字符串 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); OutputStream out =new FileOutputStream(f); String str="你好"; byte[] b=str.getBytes(); out.write(b); out.close(); }} |
查看hello.txt會看到“你好”
當然也可以一個字節一個字節的寫。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/** * 字節流 * 向文件中一個字節一個字節的寫入字符串 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); OutputStream out =new FileOutputStream(f); String str="你好"; byte[] b=str.getBytes(); for (int i =
0; i < b.length; i++) { out.write(b[i]); } out.close(); }} |
結果還是：“你好”
向文件中追加新內容：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
/** * 字節流 * 向文件中追加新內容： * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); OutputStream out =new FileOutputStream(f,true); String str="Rollen"; //String str="\r\nRollen"; 可以換行 byte[] b=str.getBytes(); for (int i =
0; i < b.length; i++) { out.write(b[i]); } out.close(); }} |
【運行結果】：
你好Rollen
【讀取文件內容】
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/** * 字節流 * 讀文件內容 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); InputStream in=new FileInputStream(f); byte[] b=new
byte[1024]; in.read(b); in.close(); System.out.println(new
String(b)); }} |
【運行結果】
你好Rollen
Rollen_
但是這個例子讀取出來會有大量的空格，我們可以利用in.read(b);的返回值來設計程序。如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/** * 字節流 * 讀文件內容 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); InputStream in=new FileInputStream(f); byte[] b=new
byte[1024]; int len=in.read(b); in.close(); System.out.println("讀入長度爲："+len); System.out.println(new
String(b,0,len)); }} |
【運行結果】：
讀入長度爲：18
你好Rollen
Rollen
讀者觀察上面的例子可以看出，我們預先申請了一個指定大小的空間，但是有時候這個空間可能太小，有時候可能太大，我們需要準確的大小，這樣節省空間，那麼我們可以這樣幹：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/** * 字節流 * 讀文件內容,節省空間 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); InputStream in=new FileInputStream(f); byte[] b=new
byte[(int)f.length()]; in.read(b); System.out.println("文件長度爲："+f.length()); in.close(); System.out.println(new
String(b)); }} |
文件長度爲：18
你好Rollen
Rollen
將上面的例子改爲一個一個讀：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/** * 字節流 * 讀文件內容,節省空間 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); InputStream in=new FileInputStream(f); byte[] b=new
byte[(int)f.length()]; for (int i =
0; i < b.length; i++) { b[i]=(byte)in.read(); } in.close(); System.out.println(new
String(b)); }} |
輸出的結果和上面的一樣。
細心的讀者可能會發現，上面的幾個例子都是在知道文件的內容多大，然後才展開的，有時候我們不知道文件有多大，這種情況下，我們需要判斷是否獨到文件的末尾。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/** * 字節流 *讀文件 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); InputStream in=new FileInputStream(f); byte[] b=new
byte[1024]; int count =0; int temp=0; while((temp=in.read())!=(-1)){ b[count++]=(byte)temp; } in.close(); System.out.println(new
String(b)); }} |
【運行結果】
你好Rollen
Rollen_
提醒一下，當獨到文件末尾的時候會返回-1.正常情況下是不會返回-1的
字符流
【向文件中寫入數據】
現在我們使用字符流
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/** * 字符流 * 寫入數據 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); Writer out =new FileWriter(f); String str="hello"; out.write(str); out.close(); }} |
當你打開hello。txt的時候，會看到hello
其實這個例子上之前的例子沒什麼區別，只是你可以直接輸入字符串，而不需要你將字符串轉化爲字節數組。
當你如果想問文件中追加內容的時候，可以使用將上面的聲明out的哪一行換爲：
Writer out =new FileWriter(f,true);
這樣，當你運行程序的時候，會發現文件內容變爲：
hellohello如果想在文件中換行的話，需要使用“\r\n”
比如將str變爲String str="\r\nhello";
這樣文件追加的str的內容就會換行了。
從文件中讀內容：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/** * 字符流 * 從文件中讀出內容 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); char[] ch=new
char[100]; Reader read=new FileReader(f); int count=read.read(ch); read.close(); System.out.println("讀入的長度爲："+count); System.out.println("內容爲"+new
String(ch,0,count)); }} |
【運行結果】：
讀入的長度爲：17
內容爲hellohello
hello
當然最好採用循環讀取的方式，因爲我們有時候不知道文件到底有多大。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/** * 字符流 * 從文件中讀出內容 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName="D:"+File.separator+"hello.txt"; File f=new File(fileName); char[] ch=new
char[100]; Reader read=new FileReader(f); int temp=0; int count=0; while((temp=read.read())!=(-1)){ ch[count++]=(char)temp; } read.close(); System.out.println("內容爲"+new
String(ch,0,count)); }} |
運行結果：
內容爲hellohello
hello
關於字節流和字符流的區別
實際上字節流在操作的時候本身是不會用到緩衝區的，是文件本身的直接操作的，但是字符流在操作的時候下後是會用到緩衝區的，是通過緩衝區來操作文件的。
讀者可以試着將上面的字節流和字符流的程序的最後一行關閉文件的代碼註釋掉，然後運行程序看看。你就會發現使用字節流的話，文件中已經存在內容，但是使用字符流的時候，文件中還是沒有內容的，這個時候就要刷新緩衝區。
使用字節流好還是字符流好呢？
答案是字節流。首先因爲硬盤上的所有文件都是以字節的形式進行傳輸或者保存的，包括圖片等內容。但是字符只是在內存中才會形成的，所以在開發中，字節流使用廣泛。
文件的複製
其實ＤＯＳ下就有一個文件複製功能，比如我們想把ｄ盤下面的ｈｅｌｌｏ．ｔｘｔ文件複製到d盤下面的rollen.txt文件中，那麼我們就可以使用下面的命令：
copy d:\hello.txt d:\rollen.txt
運行之後你會在d盤中看見hello.txt.，並且兩個文件的內容是一樣的，（這是屁話）
下面我們使用程序來複制文件吧。
基本思路還是從一個文件中讀入內容，邊讀邊寫入另一個文件，就是這麼簡單。、
首先編寫下面的代碼：
|
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
|
/** * 文件的複製 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { if(args.length!=2){ System.out.println("命令行參數輸入有誤，請檢查"); System.exit(1); } File file1=new File(args[0]); File file2=new File(args[1]); if(!file1.exists()){ System.out.println("被複制的文件不存在"); System.exit(1); } InputStream input=new FileInputStream(file1); OutputStream output=new
FileOutputStream(file2); if((input!=null)&&(output!=null)){ int temp=0; while((temp=input.read())!=(-1)){ output.write(temp); } } input.close(); output.close(); }} |
然後在命令行下面
javac hello.java
java hello d:\hello.txt d:\rollen.txt
現在你就會在d盤看到rollen。txt了，
OutputStreramWriter 和InputStreamReader類
整個IO類中除了字節流和字符流還包括字節和字符轉換流。
OutputStreramWriter將輸出的字符流轉化爲字節流
InputStreamReader將輸入的字節流轉換爲字符流
但是不管如何操作，最後都是以字節的形式保存在文件中的。
將字節輸出流轉化爲字符輸出流
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/** * 將字節輸出流轉化爲字符輸出流 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName= "d:"+File.separator+"hello.txt"; File file=new File(fileName); Writer out=new OutputStreamWriter(new
FileOutputStream(file)); out.write("hello"); out.close(); }} |
運行結果：文件中內容爲：hello
將字節輸入流變爲字符輸入流
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/** * 將字節輸入流變爲字符輸入流 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String fileName= "d:"+File.separator+"hello.txt"; File file=new File(fileName); Reader read=new InputStreamReader(new
FileInputStream(file)); char[] b=new
char[100]; int len=read.read(b); System.out.println(new
String(b,0,len)); read.close(); }} |
【運行結果】：hello
前面列舉的輸出輸入都是以文件進行的，現在我們以內容爲輸出輸入目的地，使用內存操作流
ByteArrayInputStream 主要將內容寫入內容
ByteArrayOutputStream 主要將內容從內存輸出
使用內存操作流將一個大寫字母轉化爲小寫字母
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/** * 使用內存操作流將一個大寫字母轉化爲小寫字母 * */import java.io.*;class hello{ public static void
main(String[] args) throws IOException { String str="ROLLENHOLT"; ByteArrayInputStream input=new
ByteArrayInputStream(str.getBytes()); ByteArrayOutputStream output=new
ByteArrayOutputStream(); int temp=0; while((temp=input.read())!=-1){ char ch=(char)temp; output.write(Character.toLowerCase(ch)); } String outStr=output.toString(); input.close(); output.close(); System.out.println(outStr); }} |
【運行結果】：
rollenholt
內容操作流一般使用來生成一些臨時信息採用的，這樣可以避免刪除的麻煩。
管道流
管道流主要可以進行兩個線程之間的通信。
PipedOutputStream 管道輸出流
PipedInputStream 管道輸入流
驗證管道流
|
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
|
/** * 驗證管道流 * */import java.io.*;/** * 消息發送類 * */class Send implements Runnable{ private PipedOutputStream out=null; public Send() { out=new PipedOutputStream(); } public PipedOutputStream getOut(){ return this.out; } public void run(){ String message="hello , Rollen"; try{ out.write(message.getBytes()); }catch (Exception e) { e.printStackTrace(); }try{ out.close(); }catch (Exception e) { e.printStackTrace(); } }}/** * 接受消息類 * */class Recive implements Runnable{ private PipedInputStream input=null; public Recive(){ this.input=new
PipedInputStream(); } public PipedInputStream getInput(){ return this.input; } public void run(){ byte[] b=new
byte[1000]; int len=0; try{ len=this.input.read(b); }catch (Exception e) { e.printStackTrace(); }try{ input.close(); }catch (Exception e) { e.printStackTrace(); } System.out.println("接受的內容爲 "+(new
String(b,0,len))); }}/** * 測試類 * */class hello{ public static void
main(String[] args) throws IOException { Send send=new Send(); Recive recive=new Recive(); try{//管道連接 send.getOut().connect(recive.getInput()); }catch (Exception e) { e.printStackTrace(); } new Thread(send).start(); new Thread(recive).start(); }} |
【運行結果】：
接受的內容爲 hello , Rollen
打印流
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
/** * 使用PrintStream進行輸出 * */import java.io.*;class hello { public static void
main(String[] args) throws IOException { PrintStream print = new
PrintStream(new FileOutputStream(new
File("d:" + File.separator + "hello.txt"))); print.println(true); print.println("Rollen"); print.close(); }} |
【運行結果】：
true
Rollen
當然也可以格式化輸出
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/** * 使用PrintStream進行輸出 * 並進行格式化 * */import java.io.*;class hello { public static void
main(String[] args) throws IOException { PrintStream print = new
PrintStream(new FileOutputStream(new
File("d:" + File.separator + "hello.txt"))); String name="Rollen"; int age=20; print.printf("姓名：%s. 年齡：%d.",name,age); print.close(); }} |
【運行結果】：
姓名：Rollen. 年齡：20.
使用OutputStream向屏幕上輸出內容
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
/** * 使用OutputStream向屏幕上輸出內容 * */import java.io.*;class hello { public static void
main(String[] args) throws IOException { OutputStream out=System.out; try{ out.write("hello".getBytes()); }catch (Exception e) { e.printStackTrace(); } try{ out.close(); }catch (Exception e) { e.printStackTrace(); } }} |
【運行結果】：
hello
輸入輸出重定向
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.PrintStream;/** * 爲System.out.println()重定向輸出 * */public class systemDemo{ public static void
main(String[] args){ // 此刻直接輸出到屏幕 System.out.println("hello"); File file = new File("d:"
+ File.separator + "hello.txt"); try{ System.setOut(new PrintStream(new
FileOutputStream(file))); }catch(FileNotFoundException e){ e.printStackTrace(); } System.out.println("這些內容在文件中才能看到哦！"); }} |
【運行結果】：
eclipse的控制檯輸出的是hello。然後當我們查看d盤下面的hello.txt文件的時候，會在裏面看到：這些內容在文件中才能看到哦！
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.PrintStream;/** * System.err重定向 這個例子也提示我們可以使用這種方法保存錯誤信息 * */public class systemErr{ public static void
main(String[] args){ File file = new File("d:"
+ File.separator + "hello.txt"); System.err.println("這些在控制檯輸出"); try{ System.setErr(new PrintStream(new
FileOutputStream(file))); }catch(FileNotFoundException e){ e.printStackTrace(); } System.err.println("這些在文件中才能看到哦！"); }} |
【運行結果】：
你會在eclipse的控制檯看到紅色的輸出：“這些在控制檯輸出”，然後在d盤下面的hello.txt中會看到：這些在文件中才能看到哦！
|
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
|
import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.IOException;/** * System.in重定向 * */public class systemIn{ public static void
main(String[] args){ File file = new File("d:"
+ File.separator + "hello.txt"); if(!file.exists()){ return; }else{ try{ System.setIn(new
FileInputStream(file)); }catch(FileNotFoundException e){ e.printStackTrace(); } byte[] bytes = new
byte[1024]; int len = 0; try{ len = System.in.read(bytes); }catch(IOException e){ e.printStackTrace(); } System.out.println("讀入的內容爲："
+ new String(bytes, 0, len)); } }} |
【運行結果】：
前提是我的d盤下面的hello.txt中的內容是：“這些文件中的內容哦！”，然後運行程序，輸出的結果爲：讀入的內容爲：這些文件中的內容哦！
BufferedReader的小例子
注意： BufferedReader只能接受字符流的緩衝區，因爲每一箇中文需要佔據兩個字節，所以需要將System.in這個字節輸入流變爲字符輸入流，採用：
BufferedReader buf = new BufferedReader( new InputStreamReader(System.in)); |
下面給一個實例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;/** * 使用緩衝區從鍵盤上讀入內容 * */public class BufferedReaderDemo{ public static void
main(String[] args){ BufferedReader buf = new
BufferedReader( new InputStreamReader(System.in)); String str = null; System.out.println("請輸入內容"); try{ str = buf.readLine(); }catch(IOException e){ e.printStackTrace(); } System.out.println("你輸入的內容是："
+ str); }} |
運行結果：
請輸入內容
dasdas
你輸入的內容是：dasdas
Scanner類
其實我們比較常用的是採用Scanner類來進行數據輸入，下面來給一個Scanner的例子吧
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import java.util.Scanner;/** * Scanner的小例子，從鍵盤讀數據 * */public class ScannerDemo{ public static void
main(String[] args){ Scanner sca = new Scanner(System.in); // 讀一個整數 int temp = sca.nextInt(); System.out.println(temp); //讀取浮點數 float flo=sca.nextFloat(); System.out.println(flo); //讀取字符 //...等等的，都是一些太基礎的，就不師範了。 }} |
其實Scanner可以接受任何的輸入流
下面給一個使用Scanner類從文件中讀出內容
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
import java.io.File;import java.io.FileNotFoundException;import java.util.Scanner;/** * Scanner的小例子，從文件中讀內容 * */public class ScannerDemo{ public static void
main(String[] args){ File file = new File("d:"
+ File.separator + "hello.txt"); Scanner sca = null; try{ sca = new Scanner(file); }catch(FileNotFoundException e){ e.printStackTrace(); } String str = sca.next(); System.out.println("從文件中讀取的內容是："
+ str); }} |
【運行結果】：
從文件中讀取的內容是：這些文件中的內容哦！
數據操作流DataOutputStream、DataInputStream類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import java.io.DataOutputStream;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;public class DataOutputStreamDemo{ public static void
main(String[] args) throws IOException{ File file = new File("d:"
+ File.separator + "hello.txt"); char[] ch = { 'A',
'B', 'C' }; DataOutputStream out = null; out = new DataOutputStream(new
FileOutputStream(file)); for(char temp : ch){ out.writeChar(temp); } out.close(); }} |
A B C
現在我們在上面例子的基礎上，使用DataInputStream讀出內容
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import java.io.DataInputStream;import java.io.File;import java.io.FileInputStream;import java.io.IOException;public class DataOutputStreamDemo{ public static void
main(String[] args) throws IOException{ File file = new File("d:"
+ File.separator + "hello.txt"); DataInputStream input = new
DataInputStream(new FileInputStream(file)); char[] ch = new
char[10]; int count = 0; char temp; while((temp = input.readChar()) !=
'C'){ ch[count++] = temp; } System.out.println(ch); }} |
【運行結果】：
AB
合併流 SequenceInputStream
SequenceInputStream主要用來將2個流合併在一起，比如將兩個txt中的內容合併爲另外一個txt。下面給出一個實例：
|
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.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.SequenceInputStream;/** * 將兩個文本文件合併爲另外一個文本文件 * */public class SequenceInputStreamDemo{ public static void
main(String[] args) throws IOException{ File file1 = new File("d:"
+ File.separator + "hello1.txt"); File file2 = new File("d:"
+ File.separator + "hello2.txt"); File file3 = new File("d:"
+ File.separator + "hello.txt"); InputStream input1 = new
FileInputStream(file1); InputStream input2 = new
FileInputStream(file2); OutputStream output = new
FileOutputStream(file3); // 合併流 SequenceInputStream sis = new
SequenceInputStream(input1, input2); int temp = 0; while((temp = sis.read()) != -1){ output.write(temp); } input1.close(); input2.close(); output.close(); sis.close(); }} |
【運行結果】
結果會在hello.txt文件中包含hello1.txt和hello2.txt文件中的內容。
文件壓縮 ZipOutputStream類
先舉一個壓縮單個文件的例子吧：
|
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.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;public class ZipOutputStreamDemo1{ public static void
main(String[] args) throws IOException{ File file = new File("d:"
+ File.separator + "hello.txt"); File zipFile = new File("d:"
+ File.separator + "hello.zip"); InputStream input = new
FileInputStream(file); ZipOutputStream zipOut = new
ZipOutputStream(new FileOutputStream( zipFile)); zipOut.putNextEntry(new
ZipEntry(file.getName())); // 設置註釋 zipOut.setComment("hello"); int temp = 0; while((temp = input.read()) != -1){ zipOut.write(temp); } input.close(); zipOut.close(); }} |
【運行結果】
運行結果之前，我創建了一個hello.txt的文件，原本大小56個字節，但是壓縮之後產生hello.zip之後，居然變成了175個字節，有點搞不懂。
不過結果肯定是正確的，我只是提出我的一個疑問而已。
上面的這個例子測試的是壓縮單個文件，下面的們來看看如何壓縮多個文件。
|
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
|
import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;/** * 一次性壓縮多個文件 * */public class ZipOutputStreamDemo2{ public static void
main(String[] args) throws IOException{ // 要被壓縮的文件夾 File file = new File("d:"
+ File.separator + "temp"); File zipFile = new File("d:"
+ File.separator + "zipFile.zip"); InputStream input = null; ZipOutputStream zipOut = new
ZipOutputStream(new FileOutputStream( zipFile)); zipOut.setComment("hello"); if(file.isDirectory()){ File[] files = file.listFiles(); for(int
i = 0; i < files.length; ++i){ input = new FileInputStream(files[i]); zipOut.putNextEntry(new
ZipEntry(file.getName() + File.separator + files[i].getName())); int temp = 0; while((temp = input.read()) != -1){ zipOut.write(temp); } input.close(); } } zipOut.close(); }} |
【運行結果】
先看看要被壓縮的文件吧：
接下來看看壓縮之後的：
大家自然想到，既然能壓縮，自然能解壓縮，在談解壓縮之前，我們會用到一個ZipFile類，先給一個這個例子吧。java中的每一個壓縮文件都是可以使用ZipFile來進行表示的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
import java.io.File;import java.io.IOException;import java.util.zip.ZipFile;/** * ZipFile演示 * */public class ZipFileDemo{ public static void
main(String[] args) throws IOException{ File file = new File("d:"
+ File.separator + "hello.zip"); ZipFile zipFile = new ZipFile(file); System.out.println("壓縮文件的名稱爲："
+ zipFile.getName()); }} |
【運行結果】：
壓縮文件的名稱爲：d:\hello.zip
現在我們呢是時候來看看如何加壓縮文件了，和之前一樣，先讓我們來解壓單個壓縮文件（也就是壓縮文件中只有一個文件的情況），我們採用前面的例子產生的壓縮文件hello.zip
|
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.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.util.zip.ZipEntry;import java.util.zip.ZipFile;/** * 解壓縮文件（壓縮文件中只有一個文件的情況） * */public class ZipFileDemo2{ public static void
main(String[] args) throws IOException{ File file = new File("d:"
+ File.separator + "hello.zip"); File outFile = new File("d:"
+ File.separator + "unZipFile.txt"); ZipFile zipFile = new ZipFile(file); ZipEntry entry = zipFile.getEntry("hello.txt"); InputStream input = zipFile.getInputStream(entry); OutputStream output = new
FileOutputStream(outFile); int temp = 0; while((temp = input.read()) != -1){ output.write(temp); } input.close(); output.close(); }} |
【運行結果】：
解壓縮之前：
這個壓縮文件還是175字節
解壓之後產生：
又回到了56字節，表示鬱悶。
現在讓我們來解壓一個壓縮文件中包含多個文件的情況吧
ZipInputStream類
當我們需要解壓縮多個文件的時候，ZipEntry就無法使用了，如果想操作更加複雜的壓縮文件，我們就必須使用ZipInputStream類
|
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
|
import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.util.zip.ZipEntry;import java.util.zip.ZipFile;import java.util.zip.ZipInputStream;/** * 解壓縮一個壓縮文件中包含多個文件的情況 * */public class ZipFileDemo3{ public static void
main(String[] args) throws IOException{ File file = new File("d:"
+ File.separator + "zipFile.zip"); File outFile = null; ZipFile zipFile = new ZipFile(file); ZipInputStream zipInput = new
ZipInputStream(new FileInputStream(file)); ZipEntry entry = null; InputStream input = null; OutputStream output = null; while((entry = zipInput.getNextEntry()) !=
null){ System.out.println("解壓縮"
+ entry.getName() + "文件"); outFile = new File("d:"
+ File.separator + entry.getName()); if(!outFile.getParentFile().exists()){ outFile.getParentFile().mkdir(); } if(!outFile.exists()){ outFile.createNewFile(); } input = zipFile.getInputStream(entry); output = new FileOutputStream(outFile); int temp = 0; while((temp = input.read()) != -1){ output.write(temp); } input.close(); output.close(); } }} |
【運行結果】：
被解壓的文件：
解壓之後再D盤下會出現一個temp文件夾，裏面內容：
PushBackInputStream回退流
|
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.ByteArrayInputStream;import java.io.IOException;import java.io.PushbackInputStream;/** * 回退流操作 * */public class PushBackInputStreamDemo{ public static void
main(String[] args) throws IOException{ String str = "hello,rollenholt"; PushbackInputStream push = null; ByteArrayInputStream bat = null; bat = new ByteArrayInputStream(str.getBytes()); push = new PushbackInputStream(bat); int temp = 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); } } }} |
【運行結果】：
hello(回退,) rollenholt
|
1
2
3
4
5
6
7
8
|
/** * 取得本地的默認編碼 * */public class CharSetDemo{ public static void
main(String[] args){ System.out.println("系統默認編碼爲："
+ System.getProperty("file.encoding")); }} |
【運行結果】：
系統默認編碼爲：GBK
亂碼的產生：
import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;/** * 亂碼的產生 * */public class CharSetDemo2{ public static void
main(String[] args) throws IOException{ File file = new File("d:"
+ File.separator + "hello.txt"); OutputStream out = new
FileOutputStream(file); byte[] bytes = "你好".getBytes("ISO8859-1"); out.write(bytes); out.close(); }} |
【運行結果】：
??
一般情況下產生亂碼，都是由於編碼不一致的問題。
對象的序列化
對象序列化就是把一個對象變爲二進制數據流的一種方法。
一個類要想被序列化，就行必須實現java.io.Serializable接口。雖然這個接口中沒有任何方法，就如同之前的cloneable接口一樣。實現了這個接口之後，就表示這個類具有被序列化的能力。
先讓我們實現一個具有序列化能力的類吧：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import java.io.*;/** * 實現具有序列化能力的類 * */public class SerializableDemo implements
Serializable{ public SerializableDemo(){ } public SerializableDemo(String name,
int age){ this.name=name; this.age=age; } @Override public String toString(){ return "姓名："+name+" 年齡："+age; } private String name; private int age;} |
這個類就具有實現序列化能力，
在繼續將序列化之前，先將一下ObjectInputStream和ObjectOutputStream這兩個類
先給一個ObjectOutputStream的例子吧：
|
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
|
import java.io.Serializable;import java.io.File;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectOutputStream;/** * 實現具有序列化能力的類 * */public class Person implements
Serializable{ public Person(){ } public Person(String name, int
age){ this.name = name; this.age = age; } @Override public String toString(){ return "姓名：" + name +
" 年齡：" + age; } private String name; private int age;}/** * 示範ObjectOutputStream * */public class ObjectOutputStreamDemo{ public static void
main(String[] args) throws IOException{ File file = new File("d:"
+ File.separator + "hello.txt"); ObjectOutputStream oos = new
ObjectOutputStream(new FileOutputStream( file)); oos.writeObject(new Person("rollen",
20)); oos.close(); }} |
【運行結果】：
當我們查看產生的hello.txt的時候，看到的是亂碼，呵呵。因爲是二進制文件。
雖然我們不能直接查看裏面的內容，但是我們可以使用ObjectＩｎｐｕｔＳｔｒｅａｍ類查看：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import java.io.File;import java.io.FileInputStream;import java.io.ObjectInputStream;/** * ObjectInputStream示範 * */public class ObjectInputStreamDemo{ public static void
main(String[] args) throws Exception{ File file = new File("d:"
+ File.separator + "hello.txt"); ObjectInputStream input = new
ObjectInputStream(new FileInputStream( file)); Object obj = input.readObject(); input.close(); System.out.println(obj); }} |
【運行結果】
姓名：rollen 年齡：20
到底序列化什麼內容呢？
其實只有屬性會被序列化。
Externalizable接口
被Serializable接口聲明的類的對象的屬性都將被序列化，但是如果想自定義序列化的內容的時候，就需要實現Externalizable接口。
當一個類要使用Externalizable這個接口的時候，這個類中必須要有一個無參的構造函數，如果沒有的話，在構造的時候會產生異常，這是因爲在反序列話的時候會默認調用無參的構造函數。
現在我們來演示一下序列化和反序列話：
|
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
|
package IO;import java.io.Externalizable;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInput;import java.io.ObjectInputStream;import java.io.ObjectOutput;import java.io.ObjectOutputStream;/** * 序列化和反序列化的操作 * */public class ExternalizableDemo{ public static void
main(String[] args) throws Exception{ ser(); // 序列化 dser(); // 反序列話 } public static void
ser() throws Exception{ File file = new File("d:"
+ File.separator + "hello.txt"); ObjectOutputStream out = new
ObjectOutputStream(new FileOutputStream( file)); out.writeObject(new Person("rollen",
20)); out.close(); } public static void
dser() throws Exception{ File file = new File("d:"
+ File.separator + "hello.txt"); ObjectInputStream input = new
ObjectInputStream(new FileInputStream( file)); Object obj = input.readObject(); input.close(); System.out.println(obj); }}class Person implements Externalizable{ public Person(){ } public Person(String name, int
age){ this.name = name; this.age = age; } @Override public String toString(){ return "姓名：" + name +
" 年齡：" + age; } // 複寫這個方法，根據需要可以保存的屬性或者具體內容，在序列化的時候使用 @Override public void writeExternal(ObjectOutput out)
throws IOException{ out.writeObject(this.name); out.writeInt(age); } // 複寫這個方法，根據需要讀取內容 反序列話的時候需要 @Override public void readExternal(ObjectInput in)
throws IOException, ClassNotFoundException{ this.name = (String) in.readObject(); this.age = in.readInt(); } private String name; private int age;} |
【運行結果】：
姓名：rollen 年齡：20
本例中，我們將全部的屬性都保留了下來，
Serializable接口實現的操作其實是吧一個對象中的全部屬性進行序列化，當然也可以使用我們上使用是Externalizable接口以實現部分屬性的序列化，但是這樣的操作比較麻煩，
當我們使用Serializable接口實現序列化操作的時候，如果一個對象的某一個屬性不想被序列化保存下來，那麼我們可以使用transient關鍵字進行說明：
下面舉一個例子：
|
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
|
package IO;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;/** * 序列化和反序列化的操作 * */public class serDemo{ public static void
main(String[] args) throws Exception{ ser(); // 序列化 dser(); // 反序列話 } public static void
ser() throws Exception{ File file = new File("d:"
+ File.separator + "hello.txt"); ObjectOutputStream out = new
ObjectOutputStream(new FileOutputStream( file)); out.writeObject(new Person1("rollen",
20)); out.close(); } public static void
dser() throws Exception{ File file = new File("d:"
+ File.separator + "hello.txt"); ObjectInputStream input = new
ObjectInputStream(new FileInputStream( file)); Object obj = input.readObject(); input.close(); System.out.println(obj); }}class Person1 implements Serializable{ public Person1(){ } public Person1(String name, int
age){ this.name = name; this.age = age; } @Override public String toString(){ return "姓名：" + name +
" 年齡：" + age; } // 注意這裏 private transient String name; private int age;} |
【運行結果】：
姓名：null 年齡：20
最後在給一個序列化一組對象的例子吧：
|
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
|
import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;/** * 序列化一組對象 * */public class SerDemo1{ public static void
main(String[] args) throws Exception{ Student[] stu = { new Student("hello",
20), new Student("world",
30), new Student("rollen",
40) }; ser(stu); Object[] obj = dser(); for(int i =
0; i < obj.length; ++i){ Student s = (Student) obj[i]; System.out.println(s); } } // 序列化 public static void
ser(Object[] obj) throws Exception{ File file = new File("d:"
+ File.separator + "hello.txt"); ObjectOutputStream out = new
ObjectOutputStream(new FileOutputStream( file)); out.writeObject(obj); out.close(); } // 反序列化 public static Object[] dser()
throws Exception{ File file = new File("d:"
+ File.separator + "hello.txt"); ObjectInputStream input = new
ObjectInputStream(new FileInputStream( file)); Object[] obj = (Object[]) input.readObject(); input.close(); return obj; }}class Student implements Serializable{ public Student(){ } public Student(String name, int
age){ this.name = name; this.age = age; } @Override public String toString(){ return "姓名： " + name +
" 年齡：" + age; } private String name; private int age;} |
【運行結果】：
姓名： hello 年齡：20
姓名： world 年齡：30
姓名： rollen 年齡：40