Java I/O學習（附實例和詳解）

一、Java I/O類結構以及流的基本概念

在閱讀Java I/O的實例之前我們必須清楚一些概念，我們先看看Java I/O的類結構圖：

Java I/O主要以流的形式進行讀寫數據。

流是一組有順序的，有起點和終點的字節集合，是對數據傳輸的總稱或抽象。即數據在兩設備間的傳輸稱爲流，流的本質是數據傳輸，根據數據傳輸特性將流抽象爲各種類，方便更直觀的進行數據操作。

根據處理數據的數據類型的不同可以分爲：字符流和字節流。

字符流和字節流的主要區別：

1.字節流讀取的時候，讀到一個字節就返回一個字節； 字符流使用了字節流讀到一個或多個字節（中文對應的字節數是兩個，在UTF-8碼錶中是3個字節）時。先去查指定的編碼表，將查到的字符返回。

2.字節流可以處理所有類型數據，如：圖片，MP3，AVI視頻文件，而字符流只能處理字符數據。只要是處理純文本數據，就要優先考慮使用字符流，除此之外都用字節流。

3.實際上字節流在操作時本身不會用到緩衝區（內存），是文件本身直接操作的，而字符流在操作時使用了緩衝區，通過緩衝區再操作文件。

下面我們以文件操作作爲實例進一步瞭解。

二、字符流實例

之前提到過“只要是處理純文本數據，就要優先考慮使用字符流，除此之外都用字節流”。因此本字符流操作實例是操作txt文件。對其進行讀寫操作。

2.1、一些概念

此前，我們需要了解一些概念。

Java採用16位的Unicode來表示字符串和字符的。在寫入字符流時我們都可以指定寫入的字符串的編碼。

這裏博主貼出字符流類圖結構，方便猿友閱讀：

在文件操作的時候我們主要使用到FileReader和FileWriter或BufferedReader和BufferedWriter。

從類結構圖來看：

FileReader是InputStreamReader的子類，而InputStreamReader是Reader的子類；

FileWriter是OutputStreamWriter的子類，而OutputStreamWriter則是Writer的子類。

2.2、FileReader和BufferedReader的使用

FileReader的常用構造包括以下兩種：

（1）FileReader(String fileName)：根據文件名創建FileReader對象。

（2）FileReader(File file)：根據File對象創建FileReader對象。

FileReader的常用方法包括以下幾種：

（1）int read()：讀取單個字符。返回字符的整數值，如果已經到達文件尾，則返回-1.

（2）int read(char[] cbuf)：將字符讀入cbuf字符數組。返回讀取到的字符數，如果已經到達文件尾，則返回-1.

（3）int read(char[] cbuf,int off,int len)：將讀取到的字符存放到cbuf字符數組從off標識的偏移位置開始處，最多讀取len個字符。

BufferedReader有以下兩種構造方法：

（1）BufferedReader(Reader in):根據in代表的Reader對象創建BufferReader實例，緩衝區大小採用默認值。

（2）BufferedReader(Reader in,int sz):根據in代表的Reader對象創建BufferedReader實例，緩衝區大小採用指定sz值。

BufferedReader的常用方法包括以下幾種：

（1）int read()：返回字符的整數值，如果已經到達文件尾，則返回-1.

（2）int read(char[], int, int)：將讀取到的字符存放到cbuf字符數組從off標識的偏移位置開始處，最多讀取len個字符。

（3）String readLine()：讀取一文本行。該方法遇到以下字符或者字符串認爲當前行結束：‘\n’(換行符),’\r’(回車符),’\r\n’(回車換行)。返回值爲該行內容的字符串，不包含任何行終止符，如果已到達流末尾，則返回null。

代碼實例：

package java_io;

import java.io.BufferedReader;  
import java.io.File;  
import java.io.FileNotFoundException;  
import java.io.FileReader;  
import java.io.IOException;  

public class TestReader {  

    public static void main(String[] args) {  
        TestReader testReader = new TestReader();
        String path = "C:\\Users\\luoguohui\\Desktop\\readerTest.txt";  
        testReader.readFileByFileReader(path); 
        testReader.readFileByBufferedReader(path); 
    }

    public void readFileByFileReader(String path){
        FileReader fileReader = null; 
        try {
            fileReader = new FileReader(path);  
            char[] buf = new char[1024]; //每次讀取1024個字符
            int temp = 0; 
            System.out.println("readFileByFileReader執行結果：");
            while ((temp = fileReader.read(buf)) != -1) {  
                System.out.print(new String(buf, 0, temp));  
            }
            System.out.println();
        } catch (Exception e) {
            e.printStackTrace();
        } finally { //像這種i/o操作儘量finally確保關閉
            if (fileReader!=null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void readFileByBufferedReader(String path){
        File file = new File(path);  
        if (file.isFile()) {  
            BufferedReader bufferedReader = null;  
            FileReader fileReader = null;  
            try {  
                fileReader = new FileReader(file);  
                bufferedReader = new BufferedReader(fileReader);  
                String line = bufferedReader.readLine();   
                System.out.println("readFileByBufferReader執行結果：");
                while (line != null) {  
                    System.out.println(line);   
                    line = bufferedReader.readLine();  
                }  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    fileReader.close();  
                    bufferedReader.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    } 
}  

上面代碼用到finally，關於finally雖然與I/O無關，不過這裏還是說一下：

1、不管有木有出現異常，finally塊中代碼都會執行；

2、當try和catch中有return時，finally仍然會執行；

3、finally是在return後面的表達式運算後執行的（此時並沒有返回運算後的值，而是先把要返回的值保存起來，管finally中的代碼怎麼樣，返回的值都不會改變，任然是之前保存的值），所以函數返回值是在finally執行前確定的；

4、finally中最好不要包含return，否則程序會提前退出，返回值不是try或catch中保存的返回值。

readerTest.txt文本內容：

執行結果：

2.3、FileWriter和BufferWriter的使用

FileWriter的常用構造有以下四種：

（1）FileWriter(String fileName)：根據文件名創建FileWriter對象。

（2）FileWriter(String fileName,boolean append)：根據文件名創建FileWriter對象，append參數用來指定是否在原文件之後追加內容。

（3）FileWriter(File file)：根據File對象創建FileWriter對象。

（4）FileWriter(File file,boolean append)：根據File對象創建FileWriter對象，append參數用來指定是否在原文件之後追加內容。

FileWriter的常用方法包括以下幾種：

（1）void writer(int c)：向文件中寫入正整數c代表的單個字符。

（2）void writer(char[] cbuf)：向文件中寫入字符數組cbuf。

（3）void writer(char[] cbuf,int off, in len)：向文件中寫入字符數組cbuf從偏移位置off開始的len個字符。

（4）void writer(String str)：向文件中寫入字符串str，注意此方法不會在寫入完畢之後自動換行。

（5）void writer(String str,int off,int len)：向文件中寫入字符串str的從位置off開始、長度爲len的一部分子串。

（6）Writer append(char c)：向文件中追加單個字符c。

（7）Writer append(CharSequence csq)：向文件中追加csq代表的一個字符序列。CharSequence是從JDK1.4版本開始引入的一個接口，代表字符值的一個可讀序列，此接口對許多不同種類的字符序列提供統一的只讀訪問。

（8）Writer append(CharSequence csq,int start,int end)：向文件中追加csq字符序列的從位置start開始、end結束的一部分字符。

（9）void flush()：刷新字符輸出流緩衝區。

（10）void close()：關閉字符輸出流。

BufferedWriter也擁有如下兩種形式的構造方法：

（1）BufferedWriter(Writer out): 根據out代表的Writer對象創建BufferedWriter實例，緩衝區大小採用默認值。

（2）BufferedWriter(Writer out,int sz):根據out代表的Writer對象創建BufferedWriter實例，緩衝區大小採用指定的sz值。

BufferedWriter的常用方法包括以下幾種：

（1）void close() ：關閉字符輸出流。

（2）void flush() ：刷新字符輸出流緩衝區。

（3）void newLine()： 寫入文本行。

（4）void write(char[] cbuf, int offset, int count) ：向文件中寫入字符數組cbuf從偏移位置off開始的len個字符。

（5）void write(int oneChar) ：寫入單個字符。

（6）void write(String str, int offset, int count) ：向文件中寫入字符串str的從位置off開始、長度爲len的一部分子串。

（7）以上的方法都是重寫了Writer的，還有繼承自java.io.Writer 的方法：Writer append(char c)、Writer append(CharSequence csq)、Writer append(CharSequence csq, int start, int end)、void write(char[] cbuf)、write(String str)等方法。

代碼實例：

package java_io;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;

public class TestWriter {
    public static void main(String[] args) {  
        TestWriter testWriter = new TestWriter();
        String path = "C:\\Users\\luoguohui\\Desktop\\readerTest.txt";  
        testWriter.writeFileByFileWriter(path);  
        testWriter.writeFileByBufferWriter(path);  
    }  

    public void writeFileByFileWriter(String path){
        FileWriter fileWriter = null;  
        try {  
            fileWriter = new FileWriter(path,true);             
            //將字符串寫入到流中，\r\n表示換行  
            //因爲fileWriter不會自動換行
            fileWriter.write("本行是通過fileWriter加入的行\r\n");  
            //如果想馬上看到寫入效果，則需要調用w.flush()方法  
            fileWriter.flush();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if(fileWriter != null) {  
                try {  
                    fileWriter.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }

    public void writeFileByBufferWriter(String path){
        File file = new File(path);  
        if (file.isFile()) {  
            BufferedWriter bufferedWriter = null;  
            FileWriter fileWriter = null;  
            try {  
                fileWriter = new FileWriter(file,true);  
                bufferedWriter = new BufferedWriter(fileWriter);  
                bufferedWriter.write("本行是通過bufferedWriter加入的行\r\n");  
                bufferedWriter.flush();  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    fileWriter.close();  
                    bufferedWriter.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    } 
}

我們先把readerTest.txt文件的內容清空，運行結果如下（不清空也行，只是運行結果博主的不一樣）：

三、字節流實例

3.1、實例之前

再次聲明之前提到過的“只要是處理純文本數據，就要優先考慮使用字符流，除此之外都用字節流”。

這裏博主貼出字節流類圖結構，方便猿友閱讀：

下面我們依舊以文件讀寫爲例。

3.2、FileInputStream的使用

FileInputStream的構造方法：

（1）FileInputStream(File file) ：通過打開一個到實際文件的連接來創建一個 FileInputStream，該文件通過文件系統中的 File 對象 file 指定。

（2）FileInputStream(FileDescriptor fdObj) ：通過使用文件描述符 fdObj 創建一個 FileInputStream，該文件描述符表示到文件系統中某個實際文件的現有連接。

（3）FileInputStream(String name) 通過打開一個到實際文件的連接來創建一個 FileInputStream，該文件通過文件系統中的路徑名 name 指定。

FileInputStream的常用方法：

（1）int available()：返回下一次對此輸入流調用的方法可以不受阻塞地從此輸入流讀取（或跳過）的估計剩餘字節數。

（2）void close()：關閉此文件輸入流並釋放與此流有關的所有系統資源。

（3）protected void finalize()：確保在不再引用文件輸入流時調用其 close 方法。

（4）FileChannel getChannel()：返回與此文件輸入流有關的唯一 FileChannel 對象。

（5）FileDescriptor getFD()：返回表示到文件系統中實際文件的連接的 FileDescriptor 對象，該文件系統正被此 FileInputStream 使用。

（6）int read()：從此輸入流中讀取一個數據字節。

（7）int read(byte[] b)：從此輸入流中將最多 b.length 個字節的數據讀入一個 byte 數組中。

（8）int read(byte[] b, int off, int len)：從此輸入流中將最多 len 個字節的數據讀入一個 byte 數組中。

（9）long skip(long n)：從輸入流中跳過並丟棄 n 個字節的數據。

代碼實例：

package java_io;

import java.io.FileInputStream;
import java.io.IOException;

public class TestFileInputStream {

    public static void main(String[] args) {  
        TestFileInputStream testFileInputStream = new TestFileInputStream();
        String path = "C:\\Users\\luoguohui\\Desktop\\readerTest.txt";  
        testFileInputStream.readFileByFileInputStream(path); 
    }

    public void readFileByFileInputStream(String path) {
        FileInputStream fileInputStream = null;
        try {
            // 創建文件輸入流對象
            fileInputStream = new FileInputStream(path);
            // 設定讀取的字節數
            int n = 1024;
            byte buffer[] = new byte[1024];
            // 讀取輸入流
            System.out.println("readFileByFileInputStream執行結果：");
            while ((fileInputStream.read(buffer, 0, n) != -1) && (n > 0)) {
                System.out.print(new String(buffer));
            }
            System.out.println();
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 關閉輸入流
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

readerTest.txt內容：

運行結果：

3.3、FileOutputStream 的使用

FileOutputStream的構造方法：

（1）FileOutputStream(File file) ：創建一個向指定 File 對象表示的文件中寫入數據的文件輸出流。

（2）FileOutputStream(File file, boolean append) ：創建一個向指定 File 對象表示的文件中寫入數據的文件輸出流。append參數用來指定是否在原文件之後追加內容。

（3）FileOutputStream(FileDescriptor fdObj) ：創建一個向指定文件描述符處寫入數據的輸出文件流，該文件描述符表示一個到文件系統中的某個實際文件的現有連接。

（4）FileOutputStream(String name) ：創建一個向具有指定名稱的文件中寫入數據的輸出文件流。

（5）FileOutputStream(String name, boolean append) ： 創建一個向具有指定 name 的文件中寫入數據的輸出文件流。append參數用來指定是否在原文件之後追加內容。

FileOutputStream的常用方法：

（1）void close() ：關閉此輸出流並釋放與此流有關的所有系統資源。

（2）void flush() ：刷新此輸出流並強制寫出所有緩衝的輸出字節。

（3）void write(byte[] b) ：將 b.length 個字節從指定的字節數組寫入此輸出流。

（4）void write(byte[] b, int off, int len) ：將指定字節數組中從偏移量 off 開始的 len 個字節寫入此輸出流。

（6）abstract void write(int b) ：將指定的字節寫入此輸出流。

代碼實例：

package java_io;

import java.io.FileOutputStream;

public class TestFileOutputStream {
    public static void main(String[] args) {  
        TestFileOutputStream testFileOutputStream = new TestFileOutputStream();
        String path = "C:\\Users\\luoguohui\\Desktop\\readerTest.txt";  
        testFileOutputStream.readFileByFileOutputStream(path); 
    }

    public void readFileByFileOutputStream(String path) {
        FileOutputStream fos = null;  
        try {  
            fos = new FileOutputStream(path,true);  
            String str = "這是使用FileOutputStream添加的內容\r\n";
            byte[] b = str.getBytes();
            fos.write(b);  
            fos.flush();
        } catch (Exception e) {  
            e.printStackTrace();
        } finally {  
            try {  
                fos.close();  
            } catch (Exception e2) {  
                e2.printStackTrace();
            }  
        }  
    }
}

運行結果：