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:
%dsố nguyên,%f/%.2fsố thực,%schuỗi,%bboolean,%cký tự.%nxuống dòng theo hệ điều hành (nên dùng thay cho\n).%-10scăn trái trong 10 ô,%,dcó dấu phân cách hàng nghìn.%fmặ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ềntruehoặcStandardOpenOption.APPEND. read()trả vềintchứ không phảichar, để còn chỗ cho-1bá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ằngBufferedWriter, bọc thêmPrintWriternếu cầnprintf. - Tham số charset của
FileReader/FileWriterchỉ 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
tryném lỗi rồiclose()cũng ném, lỗi củaclose()đượ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 trongfinallyđè 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
==============================
%-12scăn trái trong 12 ô,%8.2fcă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. PrintWriterkhông ném lỗi khi ghi thất bại, nên gọicheckError()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()saunextInt()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
FileWriterlẫnFiles. - 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.lineshayBufferedReader, 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.linestrả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.readLinetrong 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.