2. 程式人生 > >檔案IO流總結

檔案IO流總結

阿新 • • 發佈：2019-01-25
檔案在網路上或不同裝置之間是怎麼傳輸的，在Java程式中又是怎麼來實現檔案的傳輸，帶著這兩個問題，來了解一下Java中的IO流相關類及操作。

一、什麼是流及流的用途

　　流是一組有順序，有起點和終點的位元組的集合，是對資料傳輸的總稱和抽象。簡單說流就是在不同裝置之間進行資料傳輸。流的本質是資料傳輸，JDK為了方便開發者操作流，根據資料傳輸的各種特性，將流抽象為多種類，從而更加方便直觀的操作。

二、流的分類

　　根據處理的資料型別的不同，可將IO流分為位元組流和字元流；根據IO流的流向又可將其分為輸入流和輸出流。一般來說，如果沒有指出按什麼分類，IO流的分類預設按處理資料的型別分為：字元輸入流、字元輸出流、位元組輸入流及位元組輸出流。

三、字元流和位元組流的區別

　　字元流的由來： 因為資料編碼不同，而有了對字元進行高效操作的流物件。字元流本質是基於位元組流讀取，並查詢指定的碼錶。

l  讀寫單位不同：位元組流以位元組（8bit）為單位，字元流以字元為單位，根據碼錶對映字元，一次可能讀多個位元組。

l  處理物件不同：位元組流能處理所有型別的資料（如圖片、avi等），而字元流只能處理字元型別的資料。

結論：只要是處理純文字資料，優先考慮使用字元流。 除此之外都使用位元組流。

四、 輸入流和輸出流

　　輸入和輸出相對於記憶體而言，輸入讀入記憶體，輸出從記憶體輸出。對輸入流只能進行讀操作，對輸出流只能進行寫操作。

五、 流物件

　1) 字元輸入流   Reader

  1. Reader 是所有的輸入字元流的父類，它是一個抽象類；
  2. CharReader、StringReader 是兩種基本的介質流，它們分別將Char 陣列、String中讀取資料。PipedReader 是從與其它執行緒共用的管道中讀取資料；
  3. BufferedReader 很明顯就是一個裝飾器，它和其子類負責裝飾其它Reader 物件；
  4. FilterReader 是所有自定義具體裝飾流的父類，其子類PushbackReader 對Reader 物件進行裝飾，會增加一個行號；
  5. InputStreamReader 是一個連線位元組流和字元流的橋樑，它將位元組流轉變為字元流。FileReader 可以說是一個達到此功能、常用的工具類，在其原始碼中明顯使用了將FileInputStream 轉變為Reader 的方法。我們可以從這個類中得到一定的技巧。Reader 中各個類的用途和使用方法基本和InputStream 中的類使用一致。後面會有Reader 與InputStream 的對應關係。

　2)字元輸出流   Writer

  1. Writer 是所有的輸出字元流的父類，它是一個抽象類；
  2. CharArrayWriter、StringWriter 是兩種基本的介質流，它們分別向Char 陣列、String 中寫入資料。PipedWriter 是向與其它執行緒共用的管道中寫入資料；
  3. BufferedWriter 是一個裝飾器為Writer 提供緩衝功能；
  4. PrintWriter 和PrintStream 極其類似，功能和使用也非常相似；
  5. OutputStreamWriter 是OutputStream 到Writer 轉換的橋樑，它的子類FileWriter 其實就是一個實現此功能的具體類（具體可以研究一SourceCode）。功能和使用和OutputStream 極其類似，後面會有它們的對應圖。

　3)位元組輸入流   InputStream

  1. InputStream 是所有的輸入位元組流的父類，它是一個抽象類；
  2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三種基本的介質流，它們分別從Byte 陣列、StringBuffer、和本地檔案中讀取資料。PipedInputStream 是從與其它執行緒共用的管道中讀取資料，與Piped 相關的知識後續單獨介紹；
  3. ObjectInputStream 和所有FilterInputStream 的子類都是裝飾流（裝飾器模式的主角）。

　4)位元組輸出流   OutputStream

  1. OutputStream 是所有的輸出位元組流的父類，它是一個抽象類；
  2. ByteArrayOutputStream、FileOutputStream 是兩種基本的介質流，它們分別向Byte 陣列、和本地檔案中寫入資料。PipedOutputStream 是向與其它執行緒共用的管道中寫入資料；
  3. ObjectOutputStream 和所有FilterOutputStream 的子類都是裝飾流。

六、轉換流

　


   1)具體實現物件類

  1. InputStreamReader        位元組到字元的橋樑
  2. OutputStreamWriter       字元到位元組的橋樑

注意：這兩個流物件是字元體系中的成員，本身是字元流，所以在構造的時候需要傳入位元組流物件。

　2)特點：

  1. 字元流和位元組流之間的橋樑
  2. 可對讀取到的位元組資料經過指定編碼轉換成字元
  3. 可對讀取到的字元資料經過指定編碼轉換成位元組

　3)什麼時候使用轉換流

  1. 當位元組和字元之間有轉換動作時；
  2. 流操作的資料需要編碼或解碼時。

七、File類

　　File類是對檔案系統中檔案以及資料夾進行封裝的物件，可以通過面向物件的思想來操作檔案和資料夾。 File類儲存檔案或目錄的各種元資料資訊，包括檔名、檔案長度、最後修改時間、是否可讀、獲取當前檔案的路徑名，判斷指定檔案是否存在、獲得當前目錄中的檔案列表，建立、刪除檔案和目錄等方法。

八、RandomAccessFile類

　　該物件並不是流體系中的一員，其封裝了位元組流，同時還封裝了一個緩衝區（字元陣列），通過內部的指標來操作字元陣列中的資料。 該物件特點：
　1)該物件只能操作檔案，所以建構函式接收兩種型別的引數：a.字串檔案路徑；b.File物件。
　2)該物件既可以對檔案進行讀操作，也能進行寫操作，在進行物件例項化時可指定操作模式(r,rw)
　　注意：該物件在例項化時，如果要操作的檔案不存在，會自動建立；如果檔案存在，寫資料未指定位置，會從頭開始寫，即覆蓋原有的內容。 可以用於多執行緒下載或多個執行緒同時寫資料到檔案。
　　看完了上面的總結，不知道親是否對IO流的操作有個整體的印象，接下來還是通過程式碼來體現一下面向物件的思想吧。

package cn.dolphin.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
//import java.io.PrintWriter;

/**
 * Java中IO操作的演示
 * 
 * @author Cyanide
 * @version v1.0.0
 * @since v1.0.0
 * 
 */
public class FileDemo {
    public static void main(String[] args) throws IOException {
        // createFile();
        // copyText1();
        // copyText2();
        // copyText3();
        // copyText4();
        // copyText5();
        // copyBinary1();
        // copyBinary2();
        // copyBinary3();
        //copyBinary4();
        //codec();
        printFlow();
    }

    // -------------------------------------------------//
    //             基本類輸入輸出流物件及高效緩衝流物件            //
    // -------------------------------------------------//
    /**
     * File類的檔案目錄建立及刪除操作演示
     * 
     * @throws IOException
     */
    static void createFile() throws IOException {
        File f1 = new File("file.txt");
        File f2 = new File("directory");
        // 在當前專案目錄中建立檔案，需要處理異常。
        f1.createNewFile();
        // 在當前專案目錄中建立目錄
        f2.mkdir();
        // 刪除建立的目錄的檔案
        f1.delete();
        f2.delete();
    }

    /**
     * 文字檔案的複製操作，基本實現，每讀一個字元寫一次。
     * 
     * @throws IOException
     */
    static void copyText1() throws IOException {
        // 建立FileReader物件，丟擲FileNotFoundException。
        FileReader fileReader = new FileReader("file.txt");
        // 建立FileWriter物件，丟擲IOException。
        FileWriter fileWriter = new FileWriter("copies.txt");
        int num = 0;// fileReader.read()讀到檔案末尾返回-1。
        while ((num = fileReader.read()) != -1) {
            fileWriter.write(num);
        }
        fileWriter.close();
        fileReader.close();
        // 點評：效率低下，因此會採用第二種方式進行拷皮。
    }

    /**
     * 文字檔案的複製操作，每讀1024個字元寫一次。
     * 
     * @throws IOException
     */
    static void copyText2() throws IOException {
        FileReader fileReader = new FileReader("file.txt");
        FileWriter fileWriter = new FileWriter("copies.txt");
        // length每次讀出字元的實際長度
        int length = 0;
        char[] chs = new char[1024];
        while ((length = fileReader.read(chs)) != -1) {
            // 注意：fileReader.read()將讀到的字元存入陣列，如果最後
            // 一次讀到字元長度不足字元陣列長度時，未覆蓋索引處字元也會
            // 讀出，因此指定 length，讀多少，寫多少。
            fileWriter.write(chs, 0, length);
        }
        fileWriter.close();
        fileWriter.close();
        // 點評：效率比copyText1()高出很多，但還有更好的。
    }

    /**
     * 文字檔案的複製操作，高效快取讀寫，每次一個字元。
     * 
     * @throws IOException
     */
    static void copyText3() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(
                "file.txt"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(
                "copies.txt"));
        int num = 0;
        while ((num = bufferedReader.read()) != -1) {
            bufferedWriter.write(num);
        }
        bufferedWriter.close();
        bufferedReader.close();
    }

    /**
     * 文字檔案的複製操作，高效快取讀寫，每次讀1024個字元。
     * 
     * @throws IOException
     */
    static void copyText4() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(
                "file.txt"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(
                "copies.txt"));
        int length = 0;
        char[] chs = new char[1024];
        while ((length = bufferedReader.read(chs)) != -1) {
            bufferedWriter.write(chs, 0, length);
        }
        bufferedWriter.close();
        bufferedReader.close();
    }

    /**
     * 文字檔案的複製操作，高效快取讀寫，每次讀一行，特有方法讀寫。
     * 
     * @throws IOException
     */
    static void copyText5() throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(
                "file.txt"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(
                "copies.txt"));
        String str = null;
        while ((str = bufferedReader.readLine()) != null) {
            bufferedWriter.write(str);
            // readLine()方法讀取不帶換行，所以需要寫入換行。
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
        bufferedReader.close();
    }

    /**
     * 二進位制檔案的複製操作，基本實現，每讀一個位元組寫一次。
     * 
     * @throws IOException
     */
    static void copyBinary1() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("file.bmp");
        FileOutputStream fileOutputStream = new FileOutputStream("copies.bmp");
        int num = 0;
        while ((num = fileInputStream.read()) != -1) {
            fileOutputStream.write(num);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }

    /**
     * 二進位制檔案的複製操作，每讀1024個位元組寫一次。
     * 
     * @throws IOException
     */
    static void copyBinary2() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("file.bmp");
        FileOutputStream fileOutputStream = new FileOutputStream("copies.bmp");
        int length = 0;
        byte[] bytes = new byte[1024];
        while ((length = fileInputStream.read(bytes)) != -1) {
            fileOutputStream.write(bytes, 0, length);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }

    /**
     * 二進位制檔案的複製操作，高效快取讀寫，每次一個位元組。
     * 
     * @throws IOException
     */
    static void copyBinary3() throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(
                new FileInputStream("file.bmp"));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
                new FileOutputStream("copies.bmp"));
        int num = 0;
        while ((num = bufferedInputStream.read()) != -1) {
            bufferedOutputStream.write(num);
        }
        bufferedOutputStream.close();
        bufferedInputStream.close();
    }

    /**
     * 二進位制檔案的複製操作，高效快取讀寫，每次讀1024個位元組。
     * 
     * @throws IOException
     */
    static void copyBinary4() throws IOException {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(
                new FileInputStream("file.bmp"));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
                new FileOutputStream("copies.bmp"));
        int length = 0;
        byte[] bytes = new byte[1024];
        while ((length = bufferedInputStream.read(bytes)) != -1) {
            bufferedOutputStream.write(bytes, 0, length);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }

    // -------------------------------------------------//
    //                 緩衝高效轉換流物件                        //
    // -------------------------------------------------//
    /**
     * 高效緩衝流結合轉換流對文字進行復制編碼及解碼過程。
     * @throws IOException
     */
    static void codec() throws IOException {
        //編碼過程，將文字檔案中編碼。
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(new FileInputStream("file.txt"), "gb2312"));
        //解碼過程，將解碼後的流寫入文字檔案。
        //BufferedWriter bufferedWriter = new BufferedWriter(
                //new OutputStreamWriter(new FileOutputStream("copies.txt"),"gb2312"));
        //將鍵盤錄入內容編碼
        //System.out.print("輸入測試文字內容：");
        //BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in,"gb2312"));
        //將解碼後的流直接輸出到Console。
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out,"utf-8"));
        int length = 0;
        char[] chs = new char[1024];
        while ((length = bufferedReader.read(chs))!=-1) {
            bufferedWriter.write(chs,0,length);
        }
        bufferedWriter.close();
        bufferedReader.close();
        //總結：用什麼編碼，就用什麼解碼。 如果編碼和解碼不一致，如果上例就會出現亂碼顯示。
    }
    
    static void printFlow() throws IOException{
        BufferedReader bufferedReader = new BufferedReader(new FileReader("file.txt"));
        //將流寫入文字。
        //PrintWriter printWriter = new PrintWriter(new FileWriter("copies.txt"),true);
        //將流輸出到Console。
        PrintStream printStream = new PrintStream(System.out);
        char[] chs = new char[1024];
        while (bufferedReader.read(chs)!=-1) {
            printStream.println(chs);
            //printWriter.println(chs);
            bufferedReader.read(chs);
        }
        bufferedReader.close();
        printStream.close();
    }
}

　　最後PrintStream及PrintWriter只是輸出，沒有相應的輸入。想想Java開始的第一天那個HelloWorld就用到了PrintStream只是剛開始不明白罷了。或許現在了還有不明白的地方，但隨著知識的積累，相信學習Java會是件很快樂的事。

相關推薦

檔案IO流總結

檔案在網路上或不同裝置之間是怎麼傳輸的，在Java程式中又是怎麼來實現檔案的傳輸，帶著這兩個問題，來了解一下Java中的IO流相關類及操作。 一、什麼是流及流的用途 　　流是一組有順序，有起點和終點的位元組的集合，是對資料傳輸的總稱和抽象。簡單說流就是在不同裝置之間進行資料傳

seall的Java IO流總結

如果 com read 對稱 可能 對象實例化 它的 通過 兩個 Java流類圖結構： 流的概念和作用 流是一組有順序的，有起點和終點的字節集合，是對數據傳輸的總稱或抽象。即數據在兩設備間的傳輸稱為流，流的本質是數據傳輸，根據數據傳輸特性將流抽象為各種類，方便更直觀

IO流總結

參數 buffered strong color 父類 inpu io流 方向 9.png 按方向來分有兩種流： 　　輸入流和輸出流，這兩個通過相應的流的名字可以區分，例如InputStream和OutputStream，FileReader和FileWriter等等。

Java中的IO流總結

繼承 input buffer static tput class [] 總結 寫入 Java中的IO流總結 1. 流的繼承關系，以及字節流和字符流。 2. 節點流FileOutputStream和FileInputStream和處理流BufferedInputStream

Java IO流總結（二）-示例

一行 spa ascii 路徑名 指向 每次 字節數 判斷 pri 1.使用文件操作的9大方法完成文件的判斷 判斷文件或目錄是否存在 : exits() 返回值boolean型 * 判斷是否是文件: isFile() boolean * 判斷是否是目錄: isDie

Java IO流總結

依次 自帶 file類 文件夾 二進制文件 緩沖 rri 操作 .class 說在前面的話：IO流是用來操作File的，因此先說一下File 一、File類：文件和目錄路徑名的抽象表示。 File 類只能操作文件的屬性，文件的內容是不能操作的。 1.作用：用於對磁盤文件操作

J04-Java IO流總結二《 FileReader和FileWriter 》

示例代碼 void ati LEDE io流總結 選擇 類繼承 類構造 讀取字符串 FileReader和FileWriter的源碼非常簡單，下面通過分析它們的源碼以更好地進行理解這兩個流 1. FileReader FileReader實現了讀取底層的字節數據並將其轉

J05-Java IO流總結五 《 BufferedInputStream和BufferedOutputStream 》

com ioe 自定義 源文件 arr 是把 處理 每次 fff 1. 概念簡介 　　BufferedInputStream和BufferedOutputStream是帶緩沖區的字節輸入輸出處理流。它們本身並不具有IO流的讀取與寫入功能，只是在別的流(節點流或其他處理流)

J07-Java IO流總結七 《 InputStreamReader和OutputStreamWriter 》

trace encoder div 字節數 否則 all args system.in 兩個 　　 　　前面在介紹FileReader和FileWriter的時候有說到，FileReader的讀取字符功能，以及FileWriter的寫出字符的功能，都不是它們自己實現的，而是

Java中的IO流總結(續)

IO流中的轉換流 OutputStreamWriter是字元流通向位元組流的橋樑，可使用指定的字元流編碼表，將要寫入流中的字元編嗎成位元組，將字串按照指定的編嗎錶轉成位元組，再使用位元組流將這些位元組寫出去。對於字元轉換成位元組輸出的原理，在我們呼叫OutputStreamWriter物件的wr

Linux檔案IO快取總結

檔案IO快取 使用者空間快取（堆）—IO系統呼叫（write等）—核心空間快取記憶體—磁碟 write後立即返回，後續核心將快取區資料寫入磁碟 read從核心快取記憶體中讀取 設計目的：無需等待磁碟操作，減少磁碟操作 大塊快取空間，更少的系統呼叫，提高IO效能

Java：學員管理系統：檔案IO流版

下面將寫出具體修改，最後將放出修改過的具體程式碼以供參考： 簡單版的資訊初始化不再使用，將初始化的內容寫入到一個檔案中，方法在使用學員集合時只需要呼叫一個將檔案內容讀取並返回一個學員集合的方法即可； 具體讀取檔案的方法： //從檔案中讀取出Student集合並

c# 檔案IO流寫日誌檔案

檔案IO流寫日誌檔案         #region 系統日誌         readonly object _locklogs = new object();         /// <summary>         /// 日誌         //

Java IO流 總結

IO流分類： 1. 輸入流（讀）和輸出流（寫）。 2. 因為處理的資料不同，分為位元組流和字元流。 close()和flush()的區別： flush()：將緩衝區的資料刷到目的地中後，流可以使用。 close()：將緩衝區的資料刷到目的地中後，

IO流總結（基礎知識）

IO流總結  IO這章的知識在上面一篇部落格也說過一點，主要要體會一下裝飾者設計模式和介面卡設計模式，這樣更利於我們理解複雜的IO體系結構。今天就讓我們看一看。不過在講IO 之前，我們先把檔案（File）的知識簡單過一下。 一、檔案File 檔案大家都不陌生，檢視JDK幫助

IO流-常用的IO流總結

Java中IO流是個特別重要的知識點，IO流承包了向檔案中寫入和讀取資料的工作，是個必不可少的部分。Java.io包中最重要的就是5個類和一個介面。5個類指的是File、OutputStream、InputStream、Writer、Reader；一個介面指的是

JAVA中IO流總結

      我想你對JAVA的IO流有所瞭解，平時使用的也比較的多，但是對於其具體分類和繼承體系可能知道的並不多，可能也很少去看相關的API文件，找出其中的關係和各自的應用情形。本文簡單對常用的IO流進行分類整理，並簡單舉例說明其應用。希望本文對你有所幫助。 （A）I

C++提高 10（標準輸入，輸出流，檔案io流）

1.標準輸入流 #include<iostream> using namespace std; void main01() { int a; long b; char c[100]

21 API-IO流(字元流(編碼表,轉換流,FileReader,FileWriter,BufferedReader,BufferedWriter),IO流總結)

1:字元流(掌握)        (1)位元組流操作中文資料不是特別的方便，所以就出現了轉換流。           轉換流的作用就是把位元組流轉換字元流來使用。        (2)轉換流其實是一個字元流               字元流 = 位元組流 + 編碼表 (

IO流總結(C#篇)

FileStream(檔案流)：主要用於在二進位制檔案中讀寫二進位制資料，也可使用它讀取任何檔案       StreamReader(流讀取器)       && StreamWriter(流寫入器)：專門用於讀寫文字檔案，既可獨立關聯檔案，也可以關聯Fi