2. 程式人生 > >理解Java之IO流

理解Java之IO流

阿新 • • 發佈：2018-12-08

流是一種抽象概念，它代表了資料的無結構化傳遞。用來進行輸入輸出操作的流就稱為IO流。

IO流結構

流的分類方式

按流向分：從檔案/網路/記憶體等(資料來源)到程式是輸入流
從程式到檔案/網路/記憶體等(資料來源)是輸出流
按資料處理單位分
位元組流：以位元組為單位傳輸資料的流，以Stream結尾的都是位元組流。
字元流：以字元為單位傳輸資料的流，以Reader結尾的都是輸入字元流，以Writer結尾的都是輸出字元流。
按功能（層次）分
節點流：用於直接操作目標裝置的流
處理流(也叫過濾流)：是對一個已存在的流的連線和封裝，通過對資料的處理為程式提供更為強大、靈活的讀寫功能。

IO流的結構

如下圖所示：

IO流的結構
注意：
所有的位元組輸入流類都是InputStream的子類；所有的位元組符輸入流類都是Reader的子類；所有的位元組節輸出流類都是OutputStream的子類；所有的位元組符輸出流類都是Writer的子類，且他們都為抽象類。

IO流四大抽象類

InputStream的基本方法：

 public abstract int read() throws IOException {}//從輸入流中讀取資料的下一個位元組, 返回讀到的位元組值.若遇到流的末尾,返回-1
 public int read(byte[] b) throws IOException {}//從輸入流中讀取 b.length 個位元組的資料並存儲到緩衝區陣列b中.返回的是實際讀到的位元組總數
 public int read(byte[] b, int off, int len) throws IOException {}//讀取 len 個位元組的資料,並從陣列b的off位置開始寫入到這個陣列中
 public void close() throws IOException {}//關閉此輸入流並釋放與此流關聯的所有系統資源
 public int available() throws IOException {}//返回此輸入流下一個方法呼叫可以不受阻塞地從此輸入流讀取（或跳過）的估計位元組數
 public long skip(long n) throws IOException {}//跳過和丟棄此輸入流中資料的 n 個位元組，返回實現路過的位元組數。

OutputStream的基本方法：

public abstract void write(int b) throws IOException {}//將指定的位元組寫入此輸出流。
public void write(byte[] b) throws IOException {}// 將 b.length 個位元組從指定的 byte 陣列寫入此輸出流。
public void write(byte[] b, int off, int len) throws IOException {}//將指定 byte 陣列中從偏移量 off 開始的 len 個位元組寫入此輸出流。
public void flush() throws IOException {}//重新整理此輸出流並強制寫出所有緩衝的輸出位元組。
pulbic void close() throws IOException {}//關閉此輸出流並釋放與此流有關的所有系統資源。

Reader的基本方法：

public int read() throws IOException {}//讀取單個字元，返回作為整數讀取的字元，如果已到達流的末尾返回-1
public int read(char[] cbuf) throws IOException {}//將字元讀入陣列，返回讀取的字元數
public abstract int read(char[] cbuf, int off, int len) throws IOException {}//讀取 len 個字元的資料，並從陣列cbuf的off位置開始寫入到這個陣列中
public abstract void close() throws IOException {}//關閉該流並釋放與之關聯的所有資源
public long skip(long n) throws IOException {}//跳過n個字元。
public int available()  //還可以有多少能讀到的位元組數

Writer的基本方法：

public void write(int c) throws IOException {} //寫入單個字元
public void write(char[] cbuf) throws IOException {} //寫入字元陣列
public abstract void write(char[] cbuf, int off, int len) throws IOException {} //寫入字元陣列的某一部分
public void write(String str) throws IOException {} //寫入字串
public void write(String str, int off, int len) throws IOException {}//寫字串的某一部分
public abstract void close() throws IOException {}  //關閉此流，但要先重新整理它
public abstract void flush() throws IOException {}  //重新整理該流的緩衝，將緩衝的資料全寫到目的地

IO流的具體使用

FileInputStream 和 FileOutputStream

public static void fileInputStreamTest() {
    File f1 = new File("D:\\in.txt");
    File f2 = new File("D:\\out.txt");
    try {
        FileInputStream fi = new FileInputStream(f1); 
        FileOutputStream fo = new FileOutputStream(f2);
        byte[] buf = new byte[521];
        int len = 0;
        while((len = fi.read(buf)) != -1){
            fo.write(buf, 0, len);
        }
        fo.flush();
        fo.close();
        fi.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

PipedOutputStream和PipedintputStream

Java裡的管道輸入流PipedInputStream與管道輸出流PipedOutputStream實現了類似管道的功能，用於不同執行緒之間的相互通訊。
Java的管道輸入與輸出實際上使用的是一個迴圈緩衝陣列來實現，這個陣列預設大小為1024位元組。輸入流PipedInputStream從這個迴圈緩衝陣列中讀資料，輸出流PipedOutputStream往這個迴圈緩衝陣列中寫入資料。當這個緩衝陣列已滿的時候，輸出流PipedOutputStream所在的執行緒將阻塞；當這個緩衝陣列首次為空的時候，輸入流PipedInputStream所在的執行緒將阻塞。Java在它的jdk文件中提到不要在一個執行緒中同時使用PipeInpuStream和PipeOutputStream，這會造成死鎖。

public class WriteThread implements Runnable{
    private PipedOutputStream pout;  

    WriteThread(PipedOutputStream pout){  
      this.pout=  pout;  
    }  

    @Override
    public void run() {
        try {  
            System.out.println("W:開始將資料寫入:但等個5秒讓我們觀察...");  
            Thread.sleep(5000);  //釋放cpu執行權5秒  
            pout.write("writePiped 資料...".getBytes());  //管道輸出流  
            pout.close();  
          } catch(Exception e) {  
            throw new RuntimeException("W:WriteThread寫入失敗...");  
          }  
    }
}

public class ReadThread implements Runnable{
    private PipedInputStream pin;  

    ReadThread(PipedInputStream pin) {  
      this.pin=pin;  
    }  

    @Override
    public void run() {  //由於必須要覆蓋run方法,所以這裡不能拋,只能try  
      try {  
            System.out.println("R:讀取前沒有資料,阻塞中...等待資料傳過來再輸出到控制檯...");  
            byte[] buf = new byte[1024];  
            int len = pin.read(buf);  //read阻塞  
            System.out.println("R:讀取資料成功,阻塞解除...");  
            String s= new String(buf,0,len);  
            System.out.println(s);  //將讀取的資料流用字串以字串打印出來  
            pin.close();       
      }  catch(Exception e)  {  
            throw new RuntimeException("R:管道讀取流失敗!");  
      }     
    }  
}

public class Test {
    public static void main(String[] args) throws IOException {
          PipedInputStream pin = new PipedInputStream();  
          PipedOutputStream pout = new PipedOutputStream();  
          pin.connect(pout);  //輸入流與輸出流連線  

          ReadThread readTh   = new ReadThread(pin);  
          WriteThread writeTh = new WriteThread(pout);  
          new Thread(readTh).start();  
          new Thread(writeTh).start();  
    }
}

BufferedInputStream和BufferedOutputStream

FileInputStream和FileOutputStream 在使用時，我們介紹了可以用byte陣列作為資料讀入的快取區，以讀檔案為列，讀取硬碟的速度遠遠低於讀取記憶體的資料，為了減少對硬碟的讀取，通常從檔案中一次讀取一定長度的資料，把資料存入快取中，在寫入的時候也是一次寫入一定長度的資料，這樣可以增加檔案的讀取效率。我們在使用FileInputStream的時候是用byte陣列來做了快取，而BufferedInputStream and BufferedOutputStream已經為我們增加了這個快取功能。

public static void fileBufferTest() {
    File f1 = new File("D:\\in.txt");
    File f2 = new File("D:\\out.txt");
    try {
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(f1));   
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(f2));   
        byte[] data = new byte[1];
        while(bufferedInputStream.read(data)!=-1) {   
            bufferedOutputStream.write(data);   
        }   
        //將緩衝區中的資料全部寫出   
        bufferedOutputStream.flush();   
        bufferedInputStream.close();   
        bufferedOutputStream.close();   
    } catch (Exception e) {
        e.printStackTrace();
    }
}

讀寫物件ObjectInputStream和ObjectOutputStream

public class ObjectStream {
    public static void main(String[] args) {
        ObjectStream.objectStreamTest();
    }

    public static void objectStreamTest() {
        Demo newObject;
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("D:/123.obj")));
            oos.writeObject(new Demo());
            oos.flush();
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("D:/123.obj")));
            newObject = (Demo)ois.readObject();
            System.out.println(newObject.num);
            ois.close();
            oos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Demo implements Serializable{
    private static final long serialVersionUID = 1L;
    int num = 30;
}

SequenceInputStream

合併流，將與之相連線的流集組合成一個輸入流並從第一個輸入流開始讀取， 直到到達檔案末尾，接著從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的檔案末尾為止。 合併流的作用是將多個源合併合一個源。可接收列舉類所封閉的多個位元組流物件。

public class Test {
      public static void main(String[] args) {  
             doSequence();  
      }  

      private static void doSequence() {  
         SequenceInputStream sis = null;  // 建立一個合併流的物件  
         BufferedOutputStream bos = null;   // 建立輸出流。  
         try {  
            // 構建流集合 
            Vector<InputStream> vector = new Vector<InputStream>();  
            vector.addElement(new FileInputStream("D:/in.txt"));  
            vector.addElement(new FileInputStream("D:/out.txt"));  
            Enumeration<InputStream> e = vector.elements();  
            sis = new SequenceInputStream(e);  
            bos = new BufferedOutputStream(new FileOutputStream("/Users/zhengchao/cctv/File_OUT.txt"));  
            // 讀寫資料
            byte[] buf = new byte[1024];  
            int len = 0;  
            while ((len = sis.read(buf)) != -1) {  
               bos.write(buf, 0, len);  
               bos.flush();  
            }  
         } catch (Exception e1) {  
            e1.printStackTrace();  
         } finally {  
            try {  
               if (sis != null)  
                  sis.close();  
            } catch (IOException e) {  
               e.printStackTrace();  
            }  
            try {  
               if (bos != null)  
                  bos.close();  
            } catch (IOException e) {  
               e.printStackTrace();  
            }  
         }  
      }  
}

FileReader與FileWriter

public static void fileReaderTest() {
    File f1 = new File("D:\\in.txt");
    File f2 = new File("D:\\out.txt");
    try {
        FileReader fr = new FileReader(f1);
        FileWriter fw = new FileWriter(f2);
        char[] ch = new char[512];
        int len = 0;
        while((len = fr.read(ch)) != -1){
            fw.write(ch, 0, ch.length);
        }
        fw.flush();
        fw.close();
        fr.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

BufferedReader和BufferedWriter

public static void fileBufferReaderWriteTest() {
    File f1 = new File("D:\\in.txt");
    File f2 = new File("D:\\out.txt");
    try {
        BufferedReader br=new BufferedReader(new FileReader(f1));
        BufferedWriter bw=new BufferedWriter(new FileWriter(f2));

        String s=br.readLine();
        while(null!=s) {
            bw.write(s);
            //由於BufferedReader的readLine()是不讀入換行符的，所以寫入換行時須用newLine()方法
            bw.newLine();
            s=br.readLine();
        }
        br.close();
        bw.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

注：在使用過程中應注意將編碼格式設定為UTF-8，否則檔案寫入會亂碼。

以上只是IO流的部分類，用於對IO流相關知識進行查閱，後面再實際的工作中也會根據實際需求不斷新增。
參考自：
https://blog.csdn.net/zhengchao1991/article/details/53033137
https://blog.csdn.net/SilenceOO/article/details/50995062
https://blog.csdn.net/Yue_Chen/article/details/72772445

相關推薦

理解Java之IO流

流是一種抽象概念，它代表了資料的無結構化傳遞。用來進行輸入輸出操作的流就稱為IO流。 IO流結構 流的分類方式 按流向分：從檔案/網路/記憶體等(資料來源)到程式是輸入流 從程式到檔案/網路/記憶體等(資料來源)是輸出流 按資料處理單位分 位元組流：以位元組為單位傳輸資料的流，以Stream結尾的都是位

happy in java之io流簡介

ack 封裝 16px bsp strong 一個 硬盤 其他 file 閑來沒事，重溫馬士兵老師的java基礎。。。 流 水流的流 流氓的流，，流 英文叫做stream，溪流 流的分類： 流是用來讀寫數據的。 流就像水流一樣，File類封裝

Java 之IO流及應用

生成 介紹 lena 刷新 [0 規律 exceptio closed 形式參數 IO流 IO流概述及FileWriter類的使用 FileReader類使用 緩沖流介紹和使用 IO流相關案例 NO.one IO流概述及FileWriter類使用

java之IO流

class stream puts read void col abc div pan 1 public class Demo1_FileInputStream { 2 3 public static void main(String[] args) th

Java 輸入/輸出——理解Java的IO流

封裝 io流 理解 nbsp 磁盤 輸入流 inpu 讀取數據 節點流 1、流的分類 　　（1）輸入流和輸出流（劃分輸入/輸出流時是從程序運行所在內存的角度來考慮的） 　　　　輸入流：只能從中讀取數據，而不能向其寫入數據。 　　　　輸出流：只能向其寫入數據，而不能從中讀取數

Java基礎知識（JAVA之IO流）

恢復 資源 rip 字節流 輸出 希望 str amr 對象序列化 學習Java IO，不得不提到的就是JavaIO流。 流是一組有順序的，有起點和終點的字節集合，是對數據傳輸的總稱或抽象。即數據在兩設備間的傳輸稱為流，流的本質是數據傳輸，根據數據傳輸特

Java之IO流 FileInputStream FileOputStream

位元組流（能夠處理任何型別的資料 因為計算機儲存都是以位元組為單位 byte 一個位元組八位） 總類為 位元組輸入流 InputStream 連線硬碟和記憶體之間的管道 讀取位元組 位元組輸出流 OutputStream 從記憶體輸出到硬碟中 下面講些常用的類

Java之IO流進階篇：記憶體流，列印流，物件流

Java中的IO流，即為輸入輸出流。所謂輸入輸出流，都是相對於程式而言，程式就是這個參照物。一張圖看懂輸入輸出流：   　　輸入流抽象基類：InputStream,Reader 　　輸出流抽象基類：OutputStream,Writer 　　輸入輸出流子類眾多，詳情見下圖： 　　 1.記

java之IO流（遞迴）

一.遞迴的概述 遞迴，指在當前方法內呼叫自己的這種現象 public void method(){ System.out.println(“遞迴的演示”); //在當前方法內呼叫自己 method(); } 遞迴分為兩種，直接遞迴和間接遞迴。 直接遞迴稱為方法自身呼叫

java之IO流（位元組流）

一.位元組輸出流OutputStream OutputStream此抽象類，是表示輸出位元組流的所有類的超類。操作的資料都是位元組，定義了輸出位元組流的基本共性功能方法。 輸出流中定義都是寫write方法： close():關閉此輸出流並釋放與此流有關的所有系統資源 flush():重新整理此輸出流並

java之IO流（字元流）

一.字元編碼表 編碼表：字元和計算機二進位制的對應關係表。 ascii： 一個位元組中的7位就可以表示。對應的位元組都是正數。0-xxxxxxx iso-8859-1:拉丁碼錶 latin，用了一個位元組用的8位。1-xxxxxxx  負數。 GB2312:簡體中文碼錶。包含6000-700

java之IO流（轉換流）

一.OutputStreamWriter類 可使用指定的字元編碼表，將要寫入流中的字元編碼成位元組。它的作用的就是，將字串按照指定的編碼表轉成位元組，在使用位元組流將這些位元組寫出去。 public static void main(String[] args) throws IOExcep

java之IO流（序列化流與反序列化流）

一.物件序列化流ObjectOutputStream   用於向流中寫入物件的操作流 ObjectOutputStream   稱為 序列化流 ObjectOutputStream 將 Java 物件的基本資料型別和圖形寫入 OutputStream。可以使用 Object

java之IO流（列印流）

一.列印流 列印流新增輸出資料的功能，使它們能夠方便地列印各種資料值表示形式. 列印流根據流的分類： 1.位元組列印流 PrintStream 2.字元列印流 PrintWriter 方法： void print(String str): 輸出任意型別的資料， void println(Stri

java之IO流（二）

IO:在裝置和裝置之間的一種資料傳輸!  IO流的分類:  按流的方向分:  輸入流: 讀取檔案   (e:\\a.txt):從硬碟上檔案讀取出來後輸出這個檔案的內容 輸出流: 寫檔案:將e:\\a.txt 內容讀出來--->寫到f盤下 按資料的型別劃分:  位元組流 

java基礎之IO流及遞歸理解

示例代碼 font hid 再次 調用方法 反斜杠 filter amp 遞歸 一、IO流（簡單理解是input/output流，數據流內存到磁盤或者從磁盤到內存等） 二、File類（就是操作文件和文件夾的） 1、FIleFile類構造方法 註意：通過構造方法創建的f

Java基礎-IO流對象之序列化與反序列化

span 作者 創作 style -s 反序列化 ont 對象 io流 　　　　　　　　　　　　　　　　Java基礎-IO流對象之序列化與反序列化 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑 版權聲明：原創作品，謝絕轉載！否則將追究

Java基礎-IO流對象之隨機訪問文件（RandomAccessFile）

str 文件的 指向 poi mod 指針 println span www. 　　　　　　　　　　　　Java基礎-IO流對象之隨機訪問文件（RandomAccessFile） 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑 版權

Java學習之IO流

今天 bit string轉換 tin path 編碼表 父類 二進制 指定編碼 轉載鏈接：https://blog.csdn.net/zhaoyanjun6/article/details/54292148 Java流類圖結構： 流的概念和作用 流是一組有順序的，有起點

java基礎之IO流（一）

目標 構造方法 play pub io流 ted ima str 有一個 java基礎之IO流（一）之字節流 　　IO流體系太大，涉及到的各種流對象，我覺得很有必要總結一下。 　　那什麽是IO流，IO代表Input、Output，而流就是原始數據源與目標媒介的數據傳輸的一種