11.IO 流

落落的学习發表於2024-05-06

1.IO 流引入

概述：以應用程式為參照物，讀取資料為輸入流（Input），寫資料為輸出流（Output），大量輸入輸出資料簡稱 IO 流
原理：
image

2.IO 流的分類

讀寫的檔案分類

  • 二進位制檔案：開啟後是亂碼，或者是 16 進位制，無法生成檔案的檔案
  • 文字檔案：開啟檔案內容可以直接閱讀

IO流讀取資料內容分類

  • 字元流：讀取的內容最小單位是 char 型別
  • 位元組流：讀取的內容最小單位是 byte 型別

3.IO 流的訪問方式分類

隨機讀寫檔案：檔案中存在一個遊標，透過移動遊標的方式，改變讀寫資料的位置
順序讀寫檔案：每次都從檔案開始的位置開始讀寫

4.IO 位元組流

輸入輸出位元組流：InputStream、OutputStream
API：

  • int read()：從流中讀取一個位元組，返回值為 int 型別
  • void wirte(int b)：把一個位元組寫入到流中（把int 型別的低八位）
  • void close()：關閉管道流

4.1.檔案輸出/入位元組流

檔案流：FileInputStream（檔案輸入流）、FileOutputStream（檔案輸出流）
特點：檔案流是節點流，直接可以操作磁碟的檔案
節點流概念：能夠介質（檔案、網路、控制檯）直接相連的流
API：

  • FileInputStream(File file)
  • FileInputStream(String name)
  • FileOutputStream(String name)
  • FileOutputStream(String name, boolean append)
  • FileOutputStream(File file, boolean append)
  • FileOutputStream(File file)
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 完成檔案的複製
 */
public class FileStreamDemo {
    public static void main(String[] args) throws IOException {
        // 1.建立一個檔案輸入流
        FileInputStream fis = new FileInputStream("test.txt");
        // 2.建立一個檔案輸出流
        FileOutputStream fos = new FileOutputStream("text.txt");
        // 3.建立一個陣列
        byte[] data = new byte[1024];

        while (true) {
            // 4.讀取資料
            int len = fis.read(data);
            // 7.判斷讀取的長度是否為 -1
            if (len == -1){
                System.out.println("檔案複製成功");
                break;
            }
            // 5.寫資料
            fos.write(data, 0, len);
        }
        // 6.關閉管道流
        fis.close();
        fos.close();

    }
}

4.2.ByteArray 位元組流

Byte 位元組流：ByteArrayInputStream（位元陣列輸入流）、ByteArrayOutputStream（位元陣列輸出流）
特點：包含一個緩衝區，該緩衝區儲存從流中讀取的資料
API：

  • ByteArrayInputStream(byte[] buf)
  • ByteArrayInputStream(byte[] buf, int offset, int length)
import java.io.*;

/**
 * 檔案複製
 */
public class ByteArrayStreamDemo {
    public static void main(String[] args) throws IOException {
        // 1.建立一個檔案管道流
        FileInputStream fis = new FileInputStream("E:\\software\\developSoftware\\Java\\JavaSE\\basic\\src\\test.txt");
        // 2.建立另一個檔案輸出流
        FileOutputStream fos = new FileOutputStream("E:\\software\\developSoftware\\Java\\JavaSE\\basic\\src\\123.txt");
        // 3.建立陣列管道流
        ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
        // 5.定義陣列
        byte[] data = new byte[1024];
        while (true) {
            // 4.讀取資料
            int len = fis.read(data);
            // 7.跳出
            if (len == -1) break;
            // 6.寫資料
            bos.write(data, 0, len);
        }
        bos.writeTo(fos);
        // 8.關閉管道
        fis.close();
        fos.close();
        bos.close();
    }
}

4.3.Data 位元組流

Data 位元組流：DataInputStream（資料輸入流）、DataOutputStream（資料輸出流）
特點：讀取資料就是 Java 的資料型別，屬於處理流

import java.io.*;

public class DateStreamDemo {
    public static void main(String[] args) throws IOException {
        //1.建立輸入管道流
        DataInputStream dis = new DataInputStream(new FileInputStream("test.txt"));
        //2.建立一個輸出管道流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("text.txt"));
        //3.邊讀邊寫
        byte[] data = new byte[1024];
        while (true){
            int len = dis.read(data);
            if (len == -1) break;
            dos.write(data, 0 ,len);
        }
        //4.關閉管道
        dis.close();
        dos.close();
    }
}

4.4.緩衝位元組流

緩衝位元組流：BufferedInputStream（緩衝輸入位元組流）、BufferedOutputStream（緩衝輸出位元組流）
特點：

  • 處理了，一邊和程式連線，一邊和修飾流或者節點流連線。不能直接面對外部介質（檔案、網路）
  • 緩衝流中的緩衝區為了提高讀取或寫入的效率，將讀取或寫入的文字暫時儲存在緩衝區，當緩衝區滿了之後，一起將資料讀出或寫入，減少讀寫的次數

API：

  • BufferedInputStream(InputStream is)
  • BufferedOutputStream(InputStream is)
  • int read(byte[] b)：將讀取檔案內容放置在 byte[] 陣列中，然後返回讀取的位元組數。int：讀取的位元組數。如果讀到末尾，返回 -1
import java.io.*;

public class BufferedStreamDemo {
    public static void main(String[] args) throws IOException {
        //1.建立一個輸入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.txt"));
        //2.建立一個輸出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("text.java"));
        //3.邊讀邊寫
        byte[] data = new byte[1024];
        while (true){
            int len = bis.read();
            if (len == -1) break;
            bos.write(data, 0, len);
            bos.flush(); //當緩衝區滿了就會自動刷出
        }
        //4.關閉流
        bis.close();
        bos.close();
    }
}

5.IO 字元流

5.1.輸入輸出字元流

輸入輸出字元流：Reader（輸入字元流）、Writer（輸出字元流）
特點：

  • 讀寫的內容是字元
  • 是抽象類
  • 是字元流的根類
  • 讀取的檔案是文字檔案

PAI：

  • int read()：讀取文字檔案內容
  • void write(int )：寫入檔案
  • void close()：關閉管道

5.2.檔案輸入輸出字元流

FileReader（檔案輸入字元流）、FileWriter（檔案輸出字元流）
特點：讀資料方式是字元、屬於節點流
API：

  • FileReader(String fileName)：根據路徑載入檔案，並且建立和程式的輸入管道
  • FileWriter(String fileName)：根據路徑載入檔案，並且建立和程式的輸出管道
  • int reader(char[] c)
  • void write(char[] c);
  • void flush();
  • void close();
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //獲取檔案路徑
        String path = FileReaderDemo.class.getResource("").getPath();
        //1.建立檔案輸入字元流
        FileReader reader = new FileReader(path + "test.txt");
        //2.輸出字元流
        FileWriter writer = new FileWriter(path +"text.txt");
        while (true){
            //3.讀取檔案內容
            int buf = reader.read();
            if (buf == -1) break;
            //將字元寫入檔案
            writer.write(buf);
            //情況緩衝區
            writer.flush();
        }
        //關閉管道流
        reader.close();
        writer.close();
    }
}

相關文章