Java讀寫文件常用方法

 

一.字符流：讀寫純文本（txt，csv等），

1 字符流寫文件主要用：FileWriter，BufferedWriter，PrintWriter

1.1 測試 FileWriter 寫入

private void writeFileWriter() throws IOException {
    try (FileWriter fw = new FileWriter(basicPath + "writeUnicode_FileWriter.txt")) {
        fw.write("測試 FileWriter 寫入。");
    }
}

1.2 測試 BufferedWriter 寫入

private void writeBufferedWriter() throws IOException {
    try (BufferedWriter bw = new BufferedWriter(new FileWriter(basicPath + "writeUnicode_BufferedWriter.txt"))) {
        bw.write("測試 BufferedWriter 寫入。");
    }
}

1.3 測試 PrintWriter 寫入

private void writePrintWriter() throws IOException {
    try (PrintWriter pw = new PrintWriter(new FileWriter(basicPath + "writeUnicode_PrintWriter.txt"))) {
        pw.write("測試 PrintWriter 寫入。");
    }
}

 

2 字符流讀文件主要用：FileReader，BufferedReader

2.1 測試 FileReader 讀取

private void readFileReader() throws IOException {
    // 方式1：一個一個char讀取 （不推薦）
    try (FileReader fr = new FileReader(basicPath + "writeUnicode_FileWriter.txt")) {
        int ch;
        while ((ch = fr.read()) != -1) {
            System.out.print((char) ch);
        }
    }

    // 方式2：數組自定長度一次性讀取
    try (FileReader fr = new FileReader(basicPath + "writeUnicode_FileWriter.txt")) {
        char[] buf = new char[1024];
        int length;
        while ((length = fr.read(buf)) != -1) {
            String str = new String(buf, 0, length);
            System.out.print(str);
        }
    }
}

2.2測試 BufferedReader 讀取

private void readBufferedReader() throws IOException {
    // 方式1：一個一個char讀取 （不推薦）
    try (BufferedReader br = new BufferedReader(new FileReader(basicPath + "writeUnicode_BufferedWriter.txt"))) {
        int c;
        while ((c = br.read()) != -1) {
            System.out.print((char) c);
        }
    }

    // 方式2：數組自定長度一次性讀取
    try (BufferedReader br = new BufferedReader(new FileReader(basicPath + "writeUnicode_BufferedWriter.txt"))) {
        char[] buf = new char[1024];
        int length;
        while ((length = br.read(buf)) != -1) {
            String str = new String(buf, 0, length);
            System.out.print(str);
        }
    }

    // 方式3：bufferedReader.readLine()讀取
    try (BufferedReader br = new BufferedReader(new FileReader(basicPath + "writeUnicode_BufferedWriter.txt"))) {
        String line;
        while ((line = br.readLine()) != null) {
            System.out.print(line);
        }
    }
}

 

二.字節流：讀取視頻，音頻，二進制文件等，（文本文件也可以但不推薦，以下僅爲測試用）

1 字節流寫文件主要用：FileOutputStream，BufferedOutputStream

1.1 測試 FileOutputStream 寫入

private void writeFileOutputStream() throws IOException {
    try (FileOutputStream fos = new FileOutputStream(basicPath + "writeByte_FileOutputStream.txt")) {
        String content = "測試 FileOutputStream 寫入。";
        byte[] bytes = content.getBytes();
        fos.write(bytes);
    }
}

1.2 測試 BufferedOutputStream 寫入

private void writeBufferedOutputStream() throws IOException {
    try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(basicPath + "writeByte_BufferedOutputStream.txt"))) {
        String content = "測試 BufferedOutputStream 寫入。";
        byte[] bytes = content.getBytes();
        bos.write(bytes);
    }
}

 

2 字節流讀文件主要用：FileInputStream，BufferedInputStream

2.1 測試 FileInputStream 讀取

private void readFileInputStream() throws IOException {
    // 方式1：一個一個char讀取 （不推薦，且中文佔2個字節，此方式讀中文文件會造成亂碼）
    try (FileInputStream fis = new FileInputStream(basicPath + "writeByte_FileOutputStream.txt")) {
        int ch;
        while ((ch = fis.read()) != -1) {
            System.out.print((char) ch);
        }
    }

    // 方式2：數組自定長度一次性讀取
    try (FileInputStream fis = new FileInputStream(basicPath + "writeByte_FileOutputStream.txt")) {
        byte[] buf = new byte[1024];
        int length;
        while ((length = fis.read(buf)) != -1) {
            String str = new String(buf, 0, length);
            System.out.print(str);
        }
    }
}

2.2 測試 BufferedInputStream 讀取

private void readBufferedInputStream() throws IOException {
    // 方式1：一個一個char讀取 （不推薦，且中文佔2個字節，此方式讀中文文件會造成亂碼）
    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(basicPath + "writeByte_BufferedOutputStream.txt"))) {
        int c;
        while ((c = bis.read()) != -1) {
            System.out.print((char) c);
        }
    }

    // 方式2：數組自定長度一次性讀取
    try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(basicPath + "writeByte_BufferedOutputStream.txt"))) {
        byte[] buf = new byte[1024];
        int length;
        while ((length = bis.read(buf)) != -1) {
            String str = new String(buf, 0, length);
            System.out.print(str);
        }
    }
}

 

三.通過 Files類讀寫文件

1 測試 Files類寫入

private void writeFiles() throws IOException {
    String content = "測試 Files 類寫入。\n第二行";
    Files.write(Paths.get(basicPath + "writeFiles.txt"), content.getBytes());
}

2 測試 Files類讀取

private void readFiles() throws IOException {
    // 方式1 （文件特大時會佔滿內存）
    byte[] bytes = Files.readAllBytes(Paths.get(basicPath + "writeFiles.txt"));
    String srcStr1 = new String(bytes);
    System.out.println(srcStr1);

    // 方式2 （文件特大時會佔滿內存）
    List<String> lines = Files.readAllLines(Paths.get(basicPath + "writeFiles.txt"));
    StringBuilder sb = new StringBuilder();
    for (String line : lines) {
        // 此時line最後沒有換行，因爲readAllLines以換行分隔了所有行，可以用System.out.print 看到效果
        sb.append(line).append("\n");
    }
    String srcStr2 = sb.toString();
    System.out.println(srcStr2);

    // 方式3 JDK8的Stream流，邊消費邊讀取
    String srcStr3 = Files.lines(Paths.get(basicPath + "writeFiles.txt")).reduce((s1, s2) -> s1 + s2).get();
    System.out.println(srcStr3);
}

 

四.源碼

1 字符流讀寫

package com.writefiles;

import java.io.*;

/**
 * @author: Convict.Yellow
 * @date: 2020/12/22 16:11
 * @description: 字符流的基本單位爲 Unicode，大小爲兩個字節（Byte），主要用來處理文本數據。
 * 字符流有兩個基類：Reader（輸入字符流）和 Writer（輸出字符流）。
 * <p>
 * 字符流寫文件主要用：FileWriter，BufferedWriter，PrintWriter
 * 字符流讀文件主要用：FileReader，BufferedReader
 */
public class WriteAndReadByUnicode {

    private static final String basicPath = "D:/ztest/";

    public static void main(String[] args) throws IOException {
        WriteAndReadByUnicode entrance = new WriteAndReadByUnicode();

        // 測試 FileWriter 寫入
        entrance.writeFileWriter();
        // 測試 BufferedWriter 寫入
        entrance.writeBufferedWriter();
        // 測試 PrintWriter 寫入
        entrance.writePrintWriter();

        // 測試 FileReader 讀取
        entrance.readFileReader();
        // 測試 BufferedReader 讀取
        entrance.readBufferedReader();
    }

    private void writeFileWriter() throws IOException {
        try (FileWriter fw = new FileWriter(basicPath + "writeUnicode_FileWriter.txt")) {
            fw.write("測試 FileWriter 寫入。");
        }
    }

    private void writeBufferedWriter() throws IOException {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(basicPath + "writeUnicode_BufferedWriter.txt"))) {
            bw.write("測試 BufferedWriter 寫入。");
        }
    }

    private void writePrintWriter() throws IOException {
        try (PrintWriter pw = new PrintWriter(new FileWriter(basicPath + "writeUnicode_PrintWriter.txt"))) {
            pw.write("測試 PrintWriter 寫入。");
        }
    }

    private void readFileReader() throws IOException {
        // 方式1：一個一個char讀取 （不推薦）
        try (FileReader fr = new FileReader(basicPath + "writeUnicode_FileWriter.txt")) {
            int ch;
            while ((ch = fr.read()) != -1) {
                System.out.print((char) ch);
            }
        }

        // 方式2：數組自定長度一次性讀取
        try (FileReader fr = new FileReader(basicPath + "writeUnicode_FileWriter.txt")) {
            char[] buf = new char[1024];
            int length;
            while ((length = fr.read(buf)) != -1) {
                String str = new String(buf, 0, length);
                System.out.print(str);
            }
        }
    }

    private void readBufferedReader() throws IOException {
        // 方式1：一個一個char讀取 （不推薦）
        try (BufferedReader br = new BufferedReader(new FileReader(basicPath + "writeUnicode_BufferedWriter.txt"))) {
            int c;
            while ((c = br.read()) != -1) {
                System.out.print((char) c);
            }
        }

        // 方式2：數組自定長度一次性讀取
        try (BufferedReader br = new BufferedReader(new FileReader(basicPath + "writeUnicode_BufferedWriter.txt"))) {
            char[] buf = new char[1024];
            int length;
            while ((length = br.read(buf)) != -1) {
                String str = new String(buf, 0, length);
                System.out.print(str);
            }
        }

        // 方式3：bufferedReader.readLine()讀取
        try (BufferedReader br = new BufferedReader(new FileReader(basicPath + "writeUnicode_BufferedWriter.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.print(line);
            }
        }
    }

}

2 字節流讀寫

package com.writefiles;

import java.io.*;

/**
 * @author: Convict.Yellow
 * @date: 2020/12/22 15:27
 * @description: 字節流的基本單位爲字節（Byte），一個字節爲8位（bit），主要是用來處理二進制（數據）。
 * 字節流有兩個基類：InputStream（輸入字節流）和 OutputStream（輸出字節流）。
 * <p>
 * 字節流寫文件主要用：FileOutputStream，BufferedOutputStream
 * 字節流讀文件主要用：FileInputStream，BufferedInputStream
 */
public class WriteAndReadByByte {

    private static final String basicPath = "D:/ztest/";

    public static void main(String[] args) throws IOException {
        WriteAndReadByByte entrance = new WriteAndReadByByte();

        // 測試 FileOutputStream 寫入
        entrance.writeFileOutputStream();
        // 測試 BufferedOutputStream 寫入
        entrance.writeBufferedOutputStream();

        // 測試 FileInputStream 讀取
        entrance.readFileInputStream();
        // 測試 BufferedInputStream 讀取
        entrance.readBufferedInputStream();

    }

    private void writeFileOutputStream() throws IOException {
        try (FileOutputStream fos = new FileOutputStream(basicPath + "writeByte_FileOutputStream.txt")) {
            String content = "測試 FileOutputStream 寫入。";
            byte[] bytes = content.getBytes();
            fos.write(bytes);
        }
    }

    private void writeBufferedOutputStream() throws IOException {
        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(basicPath + "writeByte_BufferedOutputStream.txt"))) {
            String content = "測試 BufferedOutputStream 寫入。";
            byte[] bytes = content.getBytes();
            bos.write(bytes);
        }
    }

    private void readFileInputStream() throws IOException {
        // 方式1：一個一個char讀取 （不推薦，且中文佔2個字節，此方式讀中文文件會造成亂碼）
        try (FileInputStream fis = new FileInputStream(basicPath + "writeByte_FileOutputStream.txt")) {
            int ch;
            while ((ch = fis.read()) != -1) {
                System.out.print((char) ch);
            }
        }

        // 方式2：數組自定長度一次性讀取
        try (FileInputStream fis = new FileInputStream(basicPath + "writeByte_FileOutputStream.txt")) {
            byte[] buf = new byte[1024];
            int length;
            while ((length = fis.read(buf)) != -1) {
                String str = new String(buf, 0, length);
                System.out.print(str);
            }
        }
    }

    private void readBufferedInputStream() throws IOException {
        // 方式1：一個一個char讀取 （不推薦，且中文佔2個字節，此方式讀中文文件會造成亂碼）
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(basicPath + "writeByte_BufferedOutputStream.txt"))) {
            int c;
            while ((c = bis.read()) != -1) {
                System.out.print((char) c);
            }
        }

        // 方式2：數組自定長度一次性讀取
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(basicPath + "writeByte_BufferedOutputStream.txt"))) {
            byte[] buf = new byte[1024];
            int length;
            while ((length = bis.read(buf)) != -1) {
                String str = new String(buf, 0, length);
                System.out.print(str);
            }
        }
    }


}

3 Files類讀寫

package com.writefiles;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

/**
 * @author: Convict.Yellow
 * @date: 2020/12/22 16:11
 * @description:
 *
 */
public class WriteAndReadByFiles {

    private static final String basicPath = "D:/ztest/";

    public static void main(String[] args) throws IOException {
        WriteAndReadByFiles entrance = new WriteAndReadByFiles();

        // 測試 Files類寫入
        entrance.writeFiles();

        // 測試 Files類讀取
        entrance.readFiles();
    }

    private void writeFiles() throws IOException {
        String content = "測試 Files 類寫入。\n第二行";
        Files.write(Paths.get(basicPath + "writeFiles.txt"), content.getBytes());
    }

    private void readFiles() throws IOException {
        // 方式1 （文件特大時會佔滿內存）
        byte[] bytes = Files.readAllBytes(Paths.get(basicPath + "writeFiles.txt"));
        String srcStr1 = new String(bytes);
        System.out.println(srcStr1);

        // 方式2 （文件特大時會佔滿內存）
        List<String> lines = Files.readAllLines(Paths.get(basicPath + "writeFiles.txt"));
        StringBuilder sb = new StringBuilder();
        for (String line : lines) {
            // 此時line最後沒有換行，因爲readAllLines以換行分隔了所有行，可以用System.out.print 看到效果
            sb.append(line).append("\n");
        }
        String srcStr2 = sb.toString();
        System.out.println(srcStr2);

        // 方式3 JDK8的Stream流，邊消費邊讀取
        String srcStr3 = Files.lines(Paths.get(basicPath + "writeFiles.txt")).reduce((s1, s2) -> s1 + s2).get();
        System.out.println(srcStr3);
    }

}

 

Tip：均採用 try-with-resources寫法，故無需手動 close流，try-with-resources寫法可參考此處。