2017java文件操做（讀寫操做）

時間 2019-11-20

標籤 2017java java 文件讀寫欄目 Java 简体版

原文原文鏈接

java的讀寫操做是學java開發的必經之路，下面就來總結下java的讀寫操做。java

從上圖能夠開出，java的讀寫操做（輸入輸出）能夠用「流」這個概念來表示，整體而言，java的讀寫操做又分爲兩種：字符流和字節流。數組

什麼是流？網絡

流是一個抽象的概念。當Java程序須要從數據源讀取數據時，會開啓一個到數據源的流。數據源能夠是文件，內存或者網絡等。一樣，當程序須要輸出數據到目的地時也同樣會開啓一個流，數據目的地也能夠是文件、內存或者網絡等。流的建立是爲了更方便地處理數據的輸入輸出。app

那麼字節流和字符流又有什麼區別呢？eclipse

1.字節流也稱爲原始數據，須要用戶讀入後進行相應的編碼轉換。而字符流的實現是基於自動轉換的，讀取數據時會把數據按照JVM的默認編碼自動轉換成字符。編碼

2.字符流處理的單元爲2個字節的Unicode字符，分別操做字符、字符數組或字符串，而字節流處理單元爲1個字節，操做字節和字節數組。spa

因此字符流是由Java虛擬機將字節轉化爲2個字節的Unicode字符爲單位的字符而成的。code

3.字節流可用於任何類型的對象，包括二進制對象，而字符流只能處理字符或者字符串，字節流提供了處理任何類型的IO操做的功能，但它不能直接處理Unicode字符，而字符流就能夠；對象

基於以上的區別，那麼什麼狀況下用字符流，什麼狀況下用字節流呢？blog

若是是音頻文件、圖片、歌曲，就用字節流好點；若是是中文（文本）的，用字符流更好；

說了這麼多，字節流和字符流處理文件到底怎麼用呢？

稍安勿躁，讓咱們先來看看在java中，輸入輸出操做的步驟是什麼？

1 使用File類打開一個文件

2 經過字節流或字符流的子類，指定輸出的位置，注，

3 進行讀/寫操做

4 關閉輸入/輸出

IO操做屬於資源操做，必定要記得關閉

字節流：

1.按照字節流的方式從文件中讀取數據。

 1 package ioInJava.characterStream;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 
 9 public class CharIo {
10 
11     public static void main(String[] args) {
12         
13         // 第一種方式讀文件,由於方法throws了異常，因此在這要捕獲異常
14         try {
15             CharIo.readFromFileByByte();
16         } catch (FileNotFoundException e) {
17             e.printStackTrace();
18             System.out.println("找不到文件啊");
19         } catch (IOException e) {
20             e.printStackTrace();
21             System.out.println("讀不成功啊！");
22         }
23         
24         System.out.println("===========================");
25         
26         // 第二種方式讀文件
27         try {
28             CharIo.readFromFileByteTwo();
29         } catch (IOException e) {
30             e.printStackTrace();
31             System.out.println("仍是讀不成功啊！");
32         }
33         
34     }
35     
36     /**
37      * 第一種方法讀文件
38      * 經過字符流讀取文件中的數據
39      * @throws IOException 
40      */
41     public static void readFromFileByByte() throws IOException{
42         File file = new File("abc.txt");
43         // 若是文件不存在則建立文件
44         if (!file.exists()) {
45             file.createNewFile();
46         }
47         InputStream inputStream = new FileInputStream(file);
48         // 這裏定義了數組的長度是1024個字節，若是文件超出這字節，就會溢出，結果就是讀不到1024字節之後的東西
49         byte[] bs = new byte[1024];
50         // 這裏len得到的是文件中內容的長度
51         int len = inputStream.read(bs);
52         inputStream.close();
53         System.out.println(new String(bs));
54     }
55     
56     /**
57      * 第二種方法讀文件
58      * 經過字符流讀取文件中的數據
59      * @throws IOException 
60      */
61     public static void readFromFileByteTwo() throws IOException{
62         // 注意這裏的不一樣，File.separator是分隔符，這裏指明絕對路徑，即D盤根目錄下的abc.txt文件
63         File file = new File("d:" + File.separator+"abc.txt");
64         // 若是文件不存在則建立文件
65         if (!file.exists()) {
66             file.createNewFile();
67         }
68         InputStream inputStream = new FileInputStream(file);
69         // 這裏也有不一樣，能夠根據文件的大小來聲明byte數組的大小，確保能把文件讀完
70         byte[] bs = new byte[(int)file.length()];
71         // read()方法每次只能讀一個byte的內容
72         inputStream.read(bs);
73         inputStream.close();
74         System.out.println(new String(bs));
75     }
76     
77 }

2.按照字節流的方式向文件中寫入數據。

 1 package ioInJava.byteStream;
 2 
 3 import java.io.File;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.OutputStream;
 8 
 9 /**
10  * 不要被那麼多的try和catch嚇到奧，那只是由於不想在main上throws
11  * @author wsg
12  */
13 public class WriteToFile {
14 
15     public static void main(String[] args) {
16         File file = new File("D:"+File.separator+"write.doc");
17         OutputStream outputStream = null;
18         if (!file.exists()) {
19             try {
20                 // 若是文件找不到，就new一個
21                 file.createNewFile();
22             } catch (IOException e) {
23                 e.printStackTrace();
24             }
25         }
26         try {
27             // 定義輸出流，寫入文件的流
28             outputStream = new FileOutputStream(file);
29         } catch (FileNotFoundException e) {
30             e.printStackTrace();
31         }
32         // 定義將要寫入文件的數據
33         String string = "Hell Java, Hello World, 你好，世界！";
34         // 把string轉換成byte型的，並存放在數組中
35         byte[] bs = string.getBytes();
36         try {
37             // 寫入bs中的數據到file中
38             outputStream.write(bs);
39         } catch (IOException e) {
40             e.printStackTrace();
41         }
42         
43         try {
44             outputStream.close();
45         } catch (IOException e) {
46             e.printStackTrace();
47         }
48         
49         // =================到此，文件的寫入已經完成了！
50         
51         // 若是想在文件後面追加內容的話，用下面的方法
52         OutputStream outToFileEnd = null;
53         try {
54             outToFileEnd = new FileOutputStream(file,true);
55         } catch (FileNotFoundException e) {
56             e.printStackTrace();
57         }finally {// 這裏利用了finally總會被執行的特性，索性把後面的代碼都寫在finally中
58             String string2 = "Here I come!!";
59             byte[] bs2 = string2.getBytes();
60             try {
61                 outToFileEnd.write(bs2);
62             } catch (IOException e) {
63                 e.printStackTrace();
64             }finally {
65                 try {
66                     outToFileEnd.close();
67                 } catch (IOException e) {
68                     e.printStackTrace();
69                 }
70             }
71         }
72     }
73 }

=====================================================注意！！==================================================

1.初學者通常很容易搞混，或者弄不清inputstream和outpustream到底哪一個是讀數據，哪一個是寫數據，這裏要說明的是，「讀和寫」是相對於程序自己而言的，主要記清楚一點便可，那就是凡是須要提供給程序處理的數據就是輸入數據，固然就是inputstream，這裏的in是要in到程序裏面去，那麼數據從哪裏來呢，天然是從外界（網絡，內存或者文件），那麼針對文件而言，inputstream就是讀文件了。反之，凡是程序已經處理過的數據，固然要流出程序啦，那就是out咯，因此outputstream就是輸出的，那麼從程序中流出，只能到外界（網絡、內存或者文件），針對文件而言，就是寫操做啦！（一樣的道理能夠針對字符流的操做）

【簡言之，針對程序而言，in是入，out是出；這對文件而言，in是讀，out是寫！】

2.inputstream和OutputStream都是抽象類，不能實例化，使用時必須實例化一個子類（其中FileInputStream和FileOutputStream使用最多）對象來進行相關操做。

3.InputStream inputStream = new FileInputStream(fileName);當使用這個命令時，系統會提示有異常拋出，由於咱們上面定義的文件程序認爲是有可能存在，有可能不存在的，因此在eclipse中，給出了兩個解決辦法，一個是直接拋出異常聲明，由系統本身解決；另外一個是用try，catch結構處理異常！

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

3.按照字符流的方式向文件中寫入數據。

 1 package ioInJava.characterStream;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 import java.io.InputStream;
 9 import java.io.Writer;
10 
11 public class CharIo {
12 
13     public static void main(String[] args) throws IOException {
14         // 定義一個d盤根目錄下的test文檔，File.separator是分隔符
15         // 下面這句代碼，就算本來沒有這個文件，也會在對應的目錄建立一個文件
16         File file = new File("D:" + File.separator + "test.docx");
17         // 下面這也會拋出異常，此次咱們爲了代碼結構清晰起見，直接throw給main吧
18         Writer writer = new FileWriter(file);
19         String string = "今天是教師節！";
20         writer.write(string);
21         // 在這必定要記得關閉流
22         writer.close();
23     }
24 }

可是，上面的代碼有一個問題，好比，載定義一個string2，再次調用writer.write（string2）方法的時候，會發現test文件中的內容會被string2的內容覆蓋，要想實現內容追加到文件尾部，代碼以下，其實就是小小的修改，利用它的一個方法！

 1 package ioInJava.characterStream;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 import java.io.InputStream;
 9 import java.io.Writer;
10 
11 public class CharIo {
12 
13     public static void main(String[] args) throws IOException {
14         // 定義一個d盤根目錄下的test文檔，File.separator是分隔符
15         // 下面這句代碼，就算本來沒有這個文件，也會在對應的目錄建立一個文件
16         File file = new File("D:" + File.separator + "test.docx");
17         // 下面這也會拋出異常，此次咱們爲了代碼結構清晰起見，直接throw給main吧
18         // 這裏改變了writer的類型，變成了追加型
19         Writer writer = new FileWriter(file, true);
20         String string = "今天是教師節！";
21         writer.write(string);
22         String string2 = "祝願全部的老師教師節快樂！";
23         writer.write(string2);;
24         // 在這必定要記得關閉流
25         writer.close();
26     }
27 }

4.按照字符流的方式從文件中讀取數據。

 1 package ioInJava.characterStream;
 2 
 3 import java.io.File;
 4 import java.io.FileNotFoundException;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 import java.io.Reader;
 9 
10 public class ReadFromFile {
11 
12     public static void main(String[] args) throws IOException {
13         File file = new File("d:" + File.separator + "test.docx");
14         Reader reader = new FileReader(file);
15         char[] cs= new char[1024];
16         // 上面定義了一個大小爲1024的char型數組，若是文件內容過大，程序就會報錯，而不是隻讀到1024的大小
17         reader.read(cs, 0, (int)file.length());
18         System.out.println(cs);
19         reader.close();
20     }
21 
22 }

上面的代碼只能讀取內容不超過1024字符的內容，這顯然不是咱們想要的，如何讀取一個任意大小的文件呢！那麼最簡單的方法就是加大數組的空間大小了，能夠用file.length獲取文件的大小，從而定義數組的大小！char[] cs= new char[(int)file.length()];

固然，這不是最好的辦法，請看下面的代碼：

 1 package ioInJava.characterStream;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.File;
 6 import java.io.FileNotFoundException;
 7 import java.io.FileReader;
 8 import java.io.FileWriter;
 9 import java.io.IOException;
10 import java.io.Reader;
11 import java.io.Writer;
12 
13 public class ReadFromFile {
14 
15     public static void main(String[] args) throws IOException {
16         try {
17             // 聲明一個可變長的stringBuffer對象
18             StringBuffer sb = new StringBuffer("");
19             
20             /*
21              * 讀取完整文件
22              */
23             Reader reader = new FileReader("d:" + File.separator + "test.docx");
24             // 這裏咱們用到了字符操做的BufferedReader類
25             BufferedReader bufferedReader = new BufferedReader(reader);
26             String string = null;
27             // 按行讀取，結束的判斷是是否爲null，按字節或者字符讀取時結束的標誌是-1
28             while ((string = bufferedReader.readLine()) != null) {
29                 // 這裏咱們用到了StringBuffer的append方法，這個比string的「+」要高效
30                 sb.append(string + "/n");
31                 System.out.println(string);
32             }
33             // 注意這兩個關閉的順序
34             bufferedReader.close();
35             reader.close();
36             
37             /*
38              * 完整寫入文件
39              */
40             Writer writer = new FileWriter("d:" + File.separator + "test2.docx");
41             BufferedWriter bw = new BufferedWriter(writer);
42             // 注意這裏調用了toString方法
43             bw.write(sb.toString());
44             // 注意這兩個關閉的順序
45             bw.close();
46             writer.close();
47             
48         } catch (FileNotFoundException e) {
49             e.printStackTrace();
50         } catch (IOException e) {
51             e.printStackTrace();
52         }
53     }
54 }