IO流的位元組輸入輸出流（InputStream,OutputStream）

wangyudong927發表於2021-12-03

位元組輸出流與檔案位元組輸出流

  • 檔案儲存原理和記事本開啟檔案原理

  • OutputStream及FileOutputStream
import java.io.FileOutputStream;
import java.io.IOException;

/*
java.io.OutputStream:位元組輸出流
    此抽象類是表示輸出位元組流的所有類的父類
定義了一些子類共性的成員方法：
    - public void close():關閉此輸出流並釋放與此流相關聯的任何系統資源
    - public void flush():重新整理此輸出流並強制任何緩衝的輸出位元組被寫出
    - public void write(byte[] b):將b.length位元組從指定的位元組陣列寫入此輸出流
    - public void write(byte[] b, int off, int len):從指定的位元組陣列寫入len位元組，從偏移量off開始輸出到此輸出流
    - public abstract void write(int b):將指定的位元組輸出流
java.io.FileOutputStream extends OutputStream
FileOutputStream:檔案位元組輸出流
作用：把記憶體中的資料寫入到硬碟的檔案中

構造方法：
    FileOutputStream(String name)建立一個向具有指定名稱的檔案中寫入資料的輸出檔案流
    FileOutputStream(File file)建立一個向指定File物件表示的檔案中寫入資料的檔案輸出流
    引數：寫入資料的目的
        String name:目的地是一個檔案的路徑
        File file:目的地是一個檔案
    構造方法的作用：
        1.建立一個FileOutputStream物件
        2.會根據構造方法中傳遞的檔案/檔案路徑，建立一個空的檔案
        3.會把FileOutputStream物件指向建立好的檔案

    寫入資料的原理（內容-->硬碟）
        java程式-->JVM(java虛擬機器)-->os(作業系統)-->os呼叫寫資料的方法-->把資料寫入到檔案中

    位元組輸出流的使用步驟（重點）：
        1.建立一個FileOutputStream物件，構造方法中傳遞寫入資料的目的地
        2.呼叫FileOutputStream物件中的方法write，把資料寫入到檔案中
        3.釋放資源（流使用會佔用一定的記憶體，使用完畢要把記憶體清空，提高程式的效率）
 */
public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        //1.建立一個FileOutputStream物件，構造方法中傳遞寫入資料的目的地(可以輸入相對路徑，輸入完整路徑可避免錯誤)
        FileOutputStream fos = new FileOutputStream("D:\\environment\\java_project\\a.txt");
        //2.呼叫FileOutputStream物件中的方法write，把資料寫入到檔案中
        //public abstract void write(int b):將指定的位元組輸出流
        fos.write(97);
        //3.釋放資源（流使用會佔用一定的記憶體，使用完畢要把記憶體清空，提高程式的效率）
        fos.close();
    }
}
  • 一次寫多個位元組
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

/*
一次寫多個位元組的方法：
    - public void write(byte[] b):將b.length位元組從指定的位元組陣列寫入此輸出流
    - public void write(byte[] b, int off, int len):從指定的位元組陣列寫入len位元組，從偏移量off開始輸出到此輸出流
 */
public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        //建立FileOutputStream物件，構造方法中繫結要寫入資料的目的地
        FileOutputStream fos = new FileOutputStream("D:\\environment\\java_project\\javase\\b.txt");
        //呼叫FileOutputStream物件中的方法write，把資料寫入到檔案中
        //在檔案中顯示100，寫3個位元組
        fos.write(49);
        fos.write(48);
        fos.write(48);

        /*
        public void write(byte[] b):將b.length位元組從指定的位元組陣列寫入此輸出流
        一次寫多個位元組：
            如果寫的第一個位元組是正數（0-127），那麼顯示的時候會查詢ASCII表
            如果寫的第一個位元組是負數，那第一個位元組會和第二個位元組，兩個位元組組成一箇中文顯示，查詢系統預設碼錶（GBK）
         */
        byte[] btes = {65,66,67,68,69};//ABCDE
        //byte[] btes1 = {-65,-66,-67,68,69};//烤紻E
        fos.write(btes);
        //fos.write(btes1);

        /*
        public void write(byte[] b, int off, int len):把位元組陣列的一部分寫入到檔案中
            int off:陣列的開始索引
            int len:寫幾個位元組
         */
        fos.write(btes,1,2);//BC

        /*
        寫入字串的方法：可以使用String類中的方法把字串，轉換為位元組陣列
            byte[] getBytes()   把字串轉換為位元組陣列
         */
        byte[] bytes2 = "你好".getBytes();
        System.out.println(Arrays.toString(bytes2));//[-28, -67, -96, -27, -91, -67]
        fos.write(bytes2);

        //釋放資源
        fos.close();
    }
}
  • 追加寫/續寫，寫換行
import java.io.FileOutputStream;
import java.io.IOException;

/*
追加寫/續寫：使用兩個引數的構造方法
    FileOutputStream(String name, boolean append)建立一個向具有指定name的檔案中寫入資料的輸出檔案流
    FileOutputStream(File file, boolean append)建立一個向指定File物件表示的檔案中寫入資料的檔案輸出流
    引數：
        String name，File file:寫入資料的目的地
        boolean append:追加寫開關
            true:建立物件不會覆蓋原檔案，繼續在檔案的末尾追加寫資料
            false:建立一個新檔案，覆蓋原檔案
寫換行：寫換行符號
    windows:\r\n
    linux:/n
    mac:/r
 */
public class Demo03OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\\environment\\java_project\\javase\\c.txt",true);
        for (int i = 0; i < 10; i++) {
            fos.write("你好".getBytes());
            fos.write("\r\n".getBytes());
        }
        fos.close();
    }
}

位元組輸入流與文字位元組輸入流

  • FileInputStream，一次讀取單個位元組

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

/*
java.io.InputStream:位元組輸入流
此抽象類是表示位元組輸入流的所有類的超類

定義了所有子類共性的方法：
    int read()從輸入流中讀取資料的下一個位元組
    int read(byte[] b)從輸入流中讀取一定數量的位元組，並將其儲存在緩衝區陣列b中
    void close()關閉此輸入流並釋放與該流關聯的所有系統資源

java.io.FileInputStream extends InputStream
FileInputStream:檔案位元組輸入流
作用：把硬碟檔案中的資料，讀取到記憶體中使用

構造方法：
    FileInputStream(String name)
    FileInputStream(File file)
    引數：讀取檔案的資料來源
        String name：檔案的路徑
        File file：檔案
    構造方法的作用：
        1.會建立一個FileInputStream
        2.會把FileInputStream物件指定構造方法中要讀取的檔案
讀取資料的原理（硬碟-->記憶體）
    java程式-->JVM-->OS讀取資料的方法-->讀取檔案
位元組輸入流的使用步驟（重點）：
    1.建立FileInputStream物件，構造方法中繫結要讀取的資料來源
    2.使用FileInputStream物件中的方法read，讀取檔案
    3.釋放資源
 */
public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        //1.建立FileInputStream物件，構造方法中繫結要讀取的資料來源
        FileInputStream fis = new FileInputStream("D:\\environment\\java_project\\javase\\a.txt");
        //2.使用FileInputStream物件中的方法read，讀取檔案
        //int read()讀取檔案中的一個位元組並返回，讀取到檔案的末尾返回-1
        /*int len = fis.read();
        System.out.println(len);//97 a

        len = fis.read();
        System.out.println(len);//98 b

        len = fis.read();
        System.out.println(len);//99 c

        len = fis.read();
        System.out.println(len);//-1

        len = fis.read();
        System.out.println(len);//-1*/

        /*
        發現以上讀取檔案是一個重複的過程，所以可以使用迴圈優化
        不知道檔案中有多少位元組，使用while迴圈
        while迴圈結束條件，讀取到-1的時候結束

        布林表示式(len = fis.read())!=-1
            1.fis.read():讀取一個位元組
            2.len = fis.read():把讀取到的位元組賦值給變數len
            3.(len = fis.read())!=-1:判斷變數len是否不等於-1
         */
        int len = 0;//記錄讀取到的位元組
        while ((len = fis.read())!=-1){
            System.out.print((char)len);//abc，將數字再轉換成字元
        }

        /*
        while (fis.read()!=-1){
            System.out.print(fis.read());//將每次跳過一個字元讀取下一個
        }
         */

        //3.釋放資源
        fis.close();
    }
}
  • 一次讀取多個位元組

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

/*
位元組輸入流一次讀取多個位元組的方法：
    int read(byte[] b)從輸入流中讀取一定數量的位元組，並將其儲存在緩衝區陣列b中
明確兩件事情：
    1.方法的引數byte[]的作用？
        起到緩衝作用，儲存每次讀取到的多個位元組
        陣列的長度一般定義為1024（1kb）或者1024的整數倍
    2.方法的返回值int是什麼？
        每次讀取的有效位元組個數

String類的構造方法
    String(byte[] bytes):把位元組陣列轉換為字串
    String(byte[] bytes, int offset, int length):把位元組陣列的一部分轉換為字串 offset：陣列的開始索引 length：轉換的位元組個數
 */
public class Demo02InputStream {
    public static void main(String[] args) throws IOException {
        //建立FileInputStream物件，構造方法中繫結要讀取的資料來源
        FileInputStream fis = new FileInputStream("D:\\environment\\java_project\\javase\\b.txt");
        //使用FileInputStream物件中的方法read讀取檔案
        //int read(byte[] b)從輸入流中讀取一定數量的位元組，並將其儲存在緩衝區陣列b中
        /*byte[] bytes = new byte[2];
        int len = fis.read(bytes);
        System.out.println(len);//2
        System.out.println(Arrays.toString(bytes));//[65, 66]
        System.out.println(new String(bytes));//AB

        len = fis.read(bytes);
        System.out.println(len);//2
        System.out.println(new String(bytes));//CD

        len = fis.read(bytes);
        System.out.println(len);//1
        System.out.println(new String(bytes));//ED

        len = fis.read(bytes);
        System.out.println(len);//-1
        System.out.println(new String(bytes));//ED*/

        /*
        發現以上讀取是一個重複的過程，可以使用迴圈優化
        不知道檔案中有多少位元組，所以使用while迴圈
        while迴圈結束的條件，讀取到-1結束
         */
        byte[] bytes = new byte[1024];//儲存讀取到的多個位元組
        int len = 0;//記錄每次讀取到的有效位元組個數
        while ((len = fis.read(bytes))!=-1){
            //String(byte[] bytes, int offset, int length):把位元組陣列的一部分轉換為字串 offset：陣列的開始索引 length：轉換的位元組個數
            System.out.println(new String(bytes,0,len));
        }

        //釋放資源
        fis.close();
    }
}

相關文章