Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Java CoreJunior16 phút đọc

Java cơ bản: nhập xuất console và đọc ghi file text

Ôn 11 thẻ
Trong bài này

Cụm bài Java cơ bản: 1. JVM và JDK · 2. Hello World và ba loại lỗi · 3. Biến và kiểu dữ liệu · 4. Toán tử và rẽ nhánh · 5. Vòng lặp và hàm · 6. Mảng và chuỗi · 7. Console và file text · 8. Byte stream và serialization

Backend đọc ghi file text khắp nơi: import CSV, xuất báo cáo, đọc cấu hình, xử lý log. Đọc xong, bạn in và đọc console đúng cách, đọc ghi file text không mất dữ liệu, không rò file descriptor, và biết chọn API theo cỡ file. Nên đọc trước mảng và chuỗi; byte stream, buffer và serialization nằm ở bài sau: byte stream và serialization.

1. Đọc và ghi dữ liệu dạng text

Ý chính: console dùng System.out.printf để in và Scanner để đọc; file text dùng Scanner/BufferedReader để đọc và PrintWriter/BufferedWriter để ghi. Hai điều dễ sai nhất: bẫy nextLine và việc ghi đè mặc định.

Ghi ra console

Method Tác dụng
System.out.print(x) in, không xuống dòng
System.out.println(x) in rồi xuống dòng
System.out.printf(format, args...) in theo định dạng
System.out.printf("%-10s|%8.2f|%05d%n", "Cà phê", 35.5, 42);
// Cà phê    |   35.50|00042

Định dạng hay dùng:

  • %d số nguyên, %f / %.2f số thực, %s chuỗi, %b boolean, %c ký tự.
  • %n xuống dòng theo hệ điều hành (nên dùng thay cho \n).
  • %-10s căn trái trong 10 ô, %,d có dấu phân cách hàng nghìn.
  • %f mặc định in 6 chữ số thập phân (3.141593); muốn ít hơn thì ghi rõ, ví dụ %.3f.

String.format và "...".formatted(...) cùng cú pháp nhưng trả về chuỗi thay vì in. Ở backend, đừng ghi log bằng System.out; dùng logger (SLF4J + Logback) để có log level, ghi bất đồng bộ, định dạng JSON và trace id.

Đọc từ console bằng Scanner

Scanner in = new Scanner(System.in);
String word = in.next();          // một "từ", dừng ở khoảng trắng
int age = in.nextInt();           // tương tự: nextByte, nextShort, nextLong, nextFloat, nextDouble, nextBoolean
String line = in.nextLine();      // cả một dòng, tới ký tự xuống dòng

Đọc file

Scanner đọc được cả file, theo từng token (từ cách nhau bởi khoảng trắng):

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

try (Scanner sc = new Scanner(new File("data.txt"))) {   // slide thiếu từ khoá new trước File
    while (sc.hasNext()) {          // còn token để đọc không
        System.out.println(sc.next());
    }
} catch (FileNotFoundException e) {
    System.err.println("Không tìm thấy file: " + e.getMessage());
}

Ghi file

PrintWriter có print, println, printf giống System.out:

import java.io.PrintWriter;

try (PrintWriter out = new PrintWriter("report.txt")) {
    out.println("Báo cáo");
    out.print("Tổng: ");
    out.printf("%d%n", 123);
}   // try-with-resources tự gọi close(), kể cả khi có exception

FileReader, FileWriter và BufferedWriter

Đây là các class “gốc” của java.io cho file text, vẫn gặp nhiều trong code cũ và tài liệu học. Bốn điều cần nhớ:

  • Mặc định ghi đè. FileWriter, PrintWriter, Files.write đều tạo mới hoặc ghi đè file cũ. Quên điều này là mất dữ liệu; ghi nối thì truyền true hoặc StandardOpenOption.APPEND.
  • read() trả về int chứ không phải char, để còn chỗ cho -1 báo hết dữ liệu.
  • Không buffer thì rất chậm. Đọc từng ký tự trần mỗi lần là một lời gọi xuống hệ điều hành (lý do chi tiết ở bài byte stream). Thực tế đọc theo dòng bằng BufferedReader/Files.newBufferedReader, ghi bằng BufferedWriter, bọc thêm PrintWriter nếu cần printf.
  • Tham số charset của FileReader/FileWriter chỉ có từ Java 11.
Code mẫu: FileReader, FileWriter ghi đè và ghi nối, Files.write
try (FileReader reader = new FileReader("lines.txt", StandardCharsets.UTF_8)) {   // Java 11+ mới có tham số charset
    int c;
    while ((c = reader.read()) != -1) {        // read() trả về một ký tự dưới dạng int, hết file thì -1
        System.out.print((char) c);
    }
}

try (FileWriter w = new FileWriter("log.txt")) { w.write("a\n"); }          // tạo mới hoặc GHI ĐÈ file cũ
try (FileWriter w = new FileWriter("log.txt", true)) { w.write("b\n"); }    // true = ghi nối vào cuối
try (BufferedWriter w = new BufferedWriter(new FileWriter("log.txt", true))) {
    w.write("c");
    w.newLine();                                 // xuống dòng theo hệ điều hành
}
// log.txt bây giờ có 3 dòng: a, b, c

Files.write(Path.of("lines.txt"), List.of("x", "y"));                              // ghi đè
Files.write(Path.of("lines.txt"), List.of("z"), StandardOpenOption.APPEND);         // ghi nối

2. try-with-resources ở mọi nơi

Ý chính: mọi thứ giữ tài nguyên hệ điều hành phải được đóng ở đúng nơi đã mở, bằng try-with-resources. Cú pháp này đóng cả khi có exception và không làm mất lỗi gốc.

Tài nguyên ở đây là file descriptor (FD, số hiệu hệ điều hành cấp cho mỗi file hay socket đang mở) hoặc socket. Danh sách cần đóng: mọi stream, reader, writer, Scanner trên file, connection, và cả Stream từ Files.lines, Files.list, Files.walk. Chỉ Files.readAllLines, readString, readAllBytes là tự đóng vì đọc hết một lần.

  • Nhiều tài nguyên khai báo cách nhau bằng ;, được đóng ngược thứ tự mở.
  • Lỗi không bị đè. Nếu thân try ném lỗi rồi close() cũng ném, lỗi của close() được gắn vào lỗi chính dưới dạng suppressed (e.getSuppressed()). Kiểu cũ finally { in.close(); } thì lỗi trong finally đè mất lỗi gốc.

Quên đóng thì thứ cạn đầu tiên thường là FD: process chạm giới hạn ulimit -n và mọi lần mở file hay socket mới đều ném “Too many open files”. Cách tạo lại lỗi này, đếm FD của một JVM qua /proc/<pid>/fd và tìm chỗ rò có ở I/O model: blocking, epoll và file descriptor.

Ví dụ hai tài nguyên và cú pháp Java 9
try (InputStream in = new BufferedInputStream(new FileInputStream("in.mp3"));
     OutputStream out = new BufferedOutputStream(new FileOutputStream("copy.mp3"))) {
    in.transferTo(out);
}   // đóng theo thứ tự ngược: out trước, rồi in; out được flush khi đóng

Từ Java 9 có thể đưa một biến effectively final (không bị gán lại sau khi khởi tạo) đã có sẵn vào: try (in) { ... }.

3. java.nio.file.Files: lựa chọn mặc định hiện đại

Ý chính: code mới nên dùng Path + Files (NIO.2, Java 7) thay cho java.io.File: lỗi có lý do rõ ràng, mặc định UTF-8, và có sẵn hầu hết thao tác. Chọn cách đọc theo cỡ file.

java.io.File là API từ Java 1.0: nhiều method trả false thay vì nói lý do (file.delete() thất bại mà không biết vì sao). Files ném exception có thông tin (NoSuchFileException, AccessDeniedException).

flowchart LR
  A["Cần đọc file text"] --> B{"File nhỏ, vài MB?"}
  B -->|có| C["Files.readString / readAllLines"]
  B -->|không| D{"Cần kiểm soát từng dòng?"}
  D -->|không| E["Files.lines trong try-with-resources"]
  D -->|có| F["Files.newBufferedReader + readLine"]

Ghi file an toàn khi có tiến trình khác đang đọc: ghi ra file tạm trong cùng thư mục, rồi đổi tên một lần bằng ATOMIC_MOVE. Người đọc chỉ thấy file cũ hoặc file mới đầy đủ, không bao giờ thấy file ghi dở.

Path target = Path.of("report.txt");
Path tmp = Files.createTempFile(target.toAbsolutePath().getParent(), "report", ".tmp");
Files.writeString(tmp, content);
Files.move(tmp, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);

Khi nào vẫn dùng InputStream/Reader trực tiếp? Khi dữ liệu không đến từ file: HTTP body, socket, resource trong jar (getResourceAsStream), dữ liệu giải nén. Files cũng trả về chúng khi cần: Files.newInputStream, Files.newBufferedReader.

Các thao tác thường dùng của Files: đọc, ghi, copy, tạo và duyệt thư mục
Path in = Path.of("data", "students.csv");

String all = Files.readString(in);                         // file nhỏ, mặc định UTF-8
byte[] bytes = Files.readAllBytes(Path.of("logo.png"));    // file nhị phân nhỏ
long size = Files.size(in);                                // kích thước thật
boolean exists = Files.exists(in);

try (BufferedReader r = Files.newBufferedReader(in);       // file lớn: đọc theo dòng, có buffer
     BufferedWriter w = Files.newBufferedWriter(Path.of("report.txt"))) {
    String line;
    while ((line = r.readLine()) != null) {
        w.write(line.toUpperCase());
        w.newLine();
    }
}

Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);
Files.createDirectories(Path.of("out", "2026", "11"));     // tạo cả cây thư mục
try (Stream<Path> files = Files.walk(Path.of("logs"))) {   // duyệt cây thư mục, phải đóng
    files.filter(p -> p.toString().endsWith(".log")).forEach(System.out::println);
}

Bài tập

Đề đã được viết lại ngắn gọn theo cách của mình. Code đã chạy thử trên JDK 21.

1. Ghi một mảng 3 chiều ra file text.

static void write3D(int[][][] cube, Path file) throws IOException {
    try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(file))) {
        for (int layer = 0; layer < cube.length; layer++) {
            out.printf("Layer %d%n", layer);
            for (int[] row : cube[layer]) {
                StringJoiner line = new StringJoiner(" ");
                for (int x : row) line.add(String.valueOf(x));
                out.println(line);
            }
        }
    }
}

2. Đọc mọi số nguyên trong một file, tính tổng, ghi kết quả sang file khác. File có thể lẫn chữ, nên token nào không phải số thì bỏ qua:

static long sumIntegersInFile(Path in, Path out) throws IOException {
    long total = 0;
    try (Scanner sc = new Scanner(in)) {
        while (sc.hasNext()) {
            if (sc.hasNextLong()) total += sc.nextLong();
            else sc.next();                 // bỏ qua token không phải số
        }
    }
    Files.writeString(out, total + System.lineSeparator());
    return total;
}

3. Đọc danh sách sinh viên từ file CSV và xuất báo cáo. File students.txt mỗi dòng có dạng Tên,Điểm. Đọc bằng BufferedReader, chuyển mỗi dòng thành một object Student, tính điểm trung bình, rồi dùng PrintWriter ghi report.txt thành bảng thẳng cột gồm tên, điểm (2 chữ số thập phân) và PASS/FAIL (đạt khi điểm ≥ 5), cuối bảng là điểm trung bình. Xong thì in Report generated successfully to report.txt.

Lời giải Bài 3: StudentReport đầy đủ, output và điều senior làm thêm
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class StudentReport {
    record Student(String name, double score) {
        boolean passed() { return score >= 5.0; }
    }

    // Bước 1-2: đọc từng dòng "Tên,Điểm", bỏ dòng trống, báo dòng hỏng kèm số dòng
    static List<Student> readStudents(Path file) throws IOException {
        List<Student> students = new ArrayList<>();
        try (BufferedReader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
            String line;
            int lineNo = 0;
            while ((line = reader.readLine()) != null) {
                lineNo++;
                if (line.isBlank()) continue;
                String[] parts = line.split(",");
                try {
                    if (parts.length != 2) throw new IllegalArgumentException("cần đúng 2 cột");
                    String name = parts[0].strip();
                    double score = Double.parseDouble(parts[1].strip());
                    if (name.isEmpty() || score < 0 || score > 10) throw new IllegalArgumentException("tên rỗng hoặc điểm ngoài [0, 10]");
                    students.add(new Student(name, score));
                } catch (IllegalArgumentException e) {   // NumberFormatException cũng là IllegalArgumentException
                    System.err.printf("Bỏ qua dòng %d \"%s\": %s%n", lineNo, line, e.getMessage());
                }
            }
        }
        return students;
    }

    // Bước 3-4: tính trung bình và ghi báo cáo thẳng cột
    static void writeReport(List<Student> students, Path file) throws IOException {
        try (PrintWriter out = new PrintWriter(Files.newBufferedWriter(file, StandardCharsets.UTF_8))) {
            out.println("====== STUDENT REPORT ======");
            out.printf(Locale.ROOT, "%-12s%8s%10s%n", "Name", "Score", "Pass/Fail");
            out.println("-".repeat(30));
            double sum = 0;
            for (Student s : students) {
                out.printf(Locale.ROOT, "%-12s%8.2f%10s%n", s.name(), s.score(), s.passed() ? "PASS" : "FAIL");
                sum += s.score();
            }
            out.println("-".repeat(30));
            if (students.isEmpty()) out.println("Average Score: N/A");
            else out.printf(Locale.ROOT, "Average Score: %.2f%n", sum / students.size());
            out.println("=".repeat(30));
            if (out.checkError()) throw new IOException("Ghi " + file + " thất bại");
        }
    }

    public static void main(String[] args) throws IOException {
        List<Student> students = readStudents(Path.of("students.txt"));
        writeReport(students, Path.of("report.txt"));
        System.out.println("Report generated successfully to report.txt");   // bước 5
    }
}

Chạy với một file có 5 dòng hợp lệ, một dòng trống, dòng Broken line và dòng Lan,abc: hai dòng hỏng bị báo trên System.err kèm số dòng, phần còn lại vẫn ra báo cáo:

====== STUDENT REPORT ======
Name           Score Pass/Fail
------------------------------
hoidanit        8.50      PASS
Nam             6.00      PASS
An              9.20      PASS
Eric            7.50      PASS
Mai             4.25      FAIL
------------------------------
Average Score: 7.09
==============================
  • %-12s căn trái trong 12 ô, %8.2f căn phải trong 8 ô với 2 chữ số thập phân, nên cột thẳng hàng dù tên dài ngắn khác nhau. Mẫu trong đề bài căn bằng tay nên các cột bị lệch.
  • File rỗng thì không chia cho 0 mà in N/A.
  • PrintWriter không ném lỗi khi ghi thất bại, nên gọi checkError() trước khi đóng.
  • Một senior sẽ làm thêm: dùng thư viện CSV (Apache Commons CSV, Jackson CSV) vì CSV thật có dấu phẩy nằm trong ngoặc kép, có BOM, có dòng tiêu đề; quyết định rõ chính sách với dòng hỏng (bỏ qua và ghi log, hay dừng cả lô); ghi báo cáo ra file tạm rồi ATOMIC_MOVE để không ai đọc phải báo cáo ghi dở.

Ghi nhớ

  • Giải thích được vì sao nextLine() sau nextInt() trả chuỗi rỗng, và hai cách sửa.
  • Biết API nào mặc định ghi đè, và cách ghi nối bằng FileWriter lẫn Files.
  • Giải thích được try-with-resources đóng theo thứ tự nào, và suppressed exception giữ lỗi gốc ra sao.
  • Biết khi nào dùng readAllLines, Files.lines hay BufferedReader, và vì sao phải ghi rõ charset.
  • Viết được mẫu ghi file tạm cùng thư mục rồi ATOMIC_MOVE, và biết vì sao không dùng /tmp.

Câu hỏi phỏng vấn

Junior

Vì sao nextLine() đặt ngay sau nextInt() lại trả về chuỗi rỗng?

Vì nextInt() chỉ đọc con số, ký tự xuống dòng vẫn còn trong bộ đệm.

nextLine() đọc tới ký tự xuống dòng đó ngay, nên trả về chuỗi rỗng. Sửa bằng cách gọi thêm một nextLine() để bỏ ký tự đó, hoặc luôn đọc cả dòng rồi tự parse.

FileWriter ghi đè hay ghi nối? Muốn ghi nối thì làm thế nào?

Mặc định ghi đè; muốn ghi nối thì new FileWriter(path, true) hoặc truyền StandardOpenOption.APPEND.

FileWriter, PrintWriter và Files.write/writeString đều tạo file mới hoặc ghi đè file đã có. Với Files: Files.writeString(path, text, StandardOpenOption.CREATE, StandardOpenOption.APPEND). Ghi log thật thì dùng thư viện logging, nó lo cả ghi nối, xoay vòng file và ghi đồng thời từ nhiều thread.

Mid

Vì sao phải dùng try-with-resources khi làm việc với file?

Để close() luôn được gọi kể cả khi có exception: bộ đệm được ghi ra và file descriptor được trả lại.

Nếu cả khối try lẫn close() cùng ném lỗi, lỗi của close() được gắn vào lỗi chính dưới dạng suppressed exception, không làm mất lỗi gốc. Mọi class cài đặt AutoCloseable đều dùng được cách này.

Files.readAllLines, Files.lines và BufferedReader: chọn cái nào?

File nhỏ thì readAllLines/readString; file lớn thì Files.lines; cần kiểm soát từng dòng thì BufferedReader.

  • readAllLines/readString đọc hết vào bộ nhớ, gọn và tự đóng file, hợp với file nhỏ (cấu hình, vài MB).
  • Files.lines trả Stream<String> đọc lười, bộ nhớ không đổi dù file lớn, nhưng phải đóng bằng try-with-resources.
  • BufferedReader.readLine trong vòng lặp cũng đọc lười, hợp khi cần đếm số dòng, xử lý lỗi theo dòng, dừng sớm.
  • Cả ba nên chỉ rõ charset.
Vì sao nên chỉ rõ charset khi đọc ghi text? Java 18 thay đổi gì?

Vì file chỉ chứa byte: giải mã sai bảng mã ra chữ sai mà không có exception nào báo. Java 18 (JEP 400) đặt UTF-8 làm mặc định ở mọi nền tảng.

Tiếng Việt thành Viá»t là ví dụ điển hình. Trước Java 18, FileReader, FileWriter, Scanner(File), String.getBytes() dùng bảng mã mặc định của hệ điều hành, nên cùng code chạy đúng trên macOS mà hỏng trên Windows. Dù vậy vẫn nên ghi rõ StandardCharsets.UTF_8 để code đúng cả trên JDK cũ và người đọc biết ý định.

Senior

Cần xử lý một file log 20 GB thì làm thế nào?

Đọc lười từng dòng bằng Files.lines hoặc BufferedReader để bộ nhớ luôn hằng số; không bao giờ readAllLines vì sẽ hết heap.

Chỉ rõ charset. Nếu cần tốc độ thì chia file theo khoảng byte rồi xử lý song song, dùng memory-mapped file (FileChannel.map), hoặc chuyển sang công cụ xử lý luồng hay batch. Nên đo đạc trước khi tối ưu.

Làm sao ghi file để tiến trình khác không bao giờ đọc phải file ghi dở?

Ghi vào file tạm trong cùng thư mục, đóng file, rồi Files.move(tmp, target, ATOMIC_MOVE, REPLACE_EXISTING).

Việc đổi tên là nguyên tử với hệ điều hành, nên người đọc chỉ thấy file cũ hoặc file mới đầy đủ. Cần chắc dữ liệu đã xuống đĩa trước khi đổi tên (chống mất điện) thì gọi FileChannel.force(true) trên file tạm. File tạm ở thư mục khác (ví dụ /tmp) có thể nằm trên filesystem khác, khi đó move không còn nguyên tử.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
buffer /ˈbʌfər/ bộ đệm “nextInt leaves the newline character in the buffer.”
try-with-resources cú pháp tự đóng tài nguyên “I always wrap file streams in try-with-resources.”
file descriptor /dɪˈskrɪptər/ mã định danh file do hệ điều hành cấp “Forgetting to close streams can leak file descriptors.”
lazily /ˈleɪzɪli/ một cách lười (chỉ làm khi cần) “Files.lines reads the file lazily, so memory stays constant.”
charset / encoding /ˈtʃɑːrset/ bảng mã ký tự “I always pass an explicit charset when reading text files.”
append mode /əˈpend/ chế độ ghi nối “FileWriter overwrites by default; you need append mode to add to the end.”
atomic move /əˈtɑːmɪk/ đổi tên/di chuyển nguyên tử “We write to a temp file and do an atomic move so readers never see a partial file.”
delimiter /dɪˈlɪmɪtər/ ký tự phân cách “The CSV uses a comma as the delimiter, but quoted fields can contain commas too.”
malformed input /mælˈfɔːrmd/ dữ liệu đầu vào sai định dạng “We log malformed lines with their line number and keep processing the rest.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer) và tài liệu Java Core của Hỏi Dân IT, cộng thêm kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.