Cuốn sổ trong ngăn kéo#
Dùng một tệp giống như dùng một cuốn sổ cất trong ngăn kéo. Bạn mở ngăn kéo và lấy cuốn sổ ra. Bạn đọc nó từ trang đầu trở đi, hoặc bạn ghi vào đó. Rồi bạn đóng nó và cất lại. Bỏ qua bước cuối đó thì người đến đọc sau có thể thấy những ghi chú cuối của bạn chưa thật sự được viết xuống.
Java làm việc qua các luồng (stream). Luồng là dòng dữ liệu đi một hướng, như nước chảy qua vòi: luồng đầu vào chảy từ tệp vào chương trình của bạn, luồng đầu ra chảy từ chương trình của bạn vào tệp. Dữ liệu đến theo thứ tự, từ đầu; bạn không nhảy cóc.
Các lớp nằm trong hai gói, nên chương trình tệp thường bắt đầu với các lệnh import từ java.io (File, FileWriter, PrintWriter, FileReader, BufferedReader, IOException) và java.util (Scanner).
Ghi vào tệp#
Cách thân thiện nhất để ghi văn bản là PrintWriter. Nó có cùng print, println và printf mà bạn đã dùng với System.out, nhưng văn bản đi vào một tệp. Hãy bọc nó quanh một FileWriter, thứ thực sự mở tệp:
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class Write {
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(new FileWriter("scores.txt"));
out.println("Ana,91");
out.println("Ben,78");
out.printf("%s,%d%n", "Cy", 85);
out.close();
PrintWriter more = new PrintWriter(new FileWriter("scores.txt", true));
more.println("Dee,99");
more.close();
Scanner check = new Scanner(new File("scores.txt"));
while (check.hasNextLine()) {
System.out.println(check.nextLine());
}
check.close();
}
}
Ana,91
Ben,78
Cy,85
Dee,99
Mở scores.txt đã tạo ra nó, vì nó chưa tồn tại. Nếu nó đã tồn tại, nó sẽ bị làm rỗng trước: một FileWriter thông thường ghi đè. Để nối thêm vào cuối, hãy truyền true làm đối số thứ hai, new FileWriter("scores.txt", true), nghĩa là “ghi nối thêm”.
Hãy để ý throws IOException trên main. Mở tệp có thể thất bại (đĩa đầy, một thư mục bạn không được ghi), và IOException là ngoại lệ checked, nên trình biên dịch buộc bạn bắt nó hoặc khai báo nó. Khai báo giúp các đoạn mã đầu ngắn gọn; cách xử lý đúng đắn ở bên dưới.
Đóng tệp, và vì sao điều đó quan trọng#
Writer giữ văn bản trong một bộ đệm (buffer), một vùng chứa nhỏ trong bộ nhớ, và gửi nó xuống đĩa theo từng đợt vì mỗi lần đi xuống đĩa đều chậm. close() gửi những gì còn đang chờ, rồi giải phóng tệp. Quên nó, và đợt cuối, mà với một tệp nhỏ là tất cả, có thể không bao giờ đến nơi:
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class NoClose {
static int linesIn(String name) throws FileNotFoundException {
Scanner in = new Scanner(new File(name));
int n = 0;
while (in.hasNextLine()) {
in.nextLine();
n++;
}
in.close();
return n;
}
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(new FileWriter("notes.txt"));
out.println("first line");
out.println("second line");
out.println("third line");
System.out.println("Lines in the file before close: " + linesIn("notes.txt"));
out.close();
System.out.println("Lines in the file after close: " + linesIn("notes.txt"));
}
}
Lines in the file before close: 0
Lines in the file after close: 3
Chương trình đã ghi ba dòng, vậy mà trước close() tệp không chứa dòng nào: chúng vẫn nằm trong bộ đệm. Sau close() cả ba đều có mặt. Đóng cũng giải phóng tệp để các chương trình khác dùng được. Cách hiện đại để đảm bảo tệp luôn được đóng, kể cả khi có ngoại lệ giữa chừng, là try-with-resources: mở tệp trong dấu ngoặc ngay sau try, và Java tự động đóng nó khi khối kết thúc.
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class Resources {
public static void main(String[] args) throws IOException {
try (PrintWriter out = new PrintWriter(new FileWriter("log.txt"))) {
for (int i = 1; i <= 3; i++) {
out.println("entry " + i);
}
}
try (Scanner in = new Scanner(new File("log.txt"))) {
while (in.hasNextLine()) {
System.out.println("read back: " + in.nextLine());
}
}
}
}
read back: entry 1
read back: entry 2
read back: entry 3
Không có lời gọi close() nào, mà tệp vẫn được đóng, đó là lý do khối thứ hai đọc lại được cả ba mục. Scanner dùng để đọc cũng được đóng theo cách tương tự. Đây là dạng try duy nhất có thể đứng một mình mà không có catch hoặc finally.
Đọc bằng Scanner#
Bạn đã biết Scanner từ việc đọc bàn phím. Hãy trỏ nó vào một đối tượng File thay vì System.in và nó đọc tệp bằng cùng các phương thức: nextLine, nextInt, next, và các phương thức hasNext... hỏi xem còn gì không.
Tệp scores.txt chứa:
Ana,91
Ben,78
Cy,85
Dee,99
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class ReadScanner {
public static void main(String[] args) throws FileNotFoundException {
Scanner in = new Scanner(new File("scores.txt"));
int count = 0, total = 0;
while (in.hasNextLine()) {
String line = in.nextLine();
String[] parts = line.split(",");
int score = Integer.parseInt(parts[1]);
System.out.println(parts[0] + " scored " + score);
count++;
total += score;
}
in.close();
System.out.println("Average of " + count + ": " + (double) total / count);
}
}
Ana scored 91
Ben scored 78
Cy scored 85
Dee scored 99
Average of 4: 88.25
Mẫu vòng lặp cần nhớ là: trong khi hasNextLine(), gọi nextLine(). Bên trong, split(",") cắt dòng ở mỗi dấu phẩy thành một mảng các mảnh, và Integer.parseInt biến văn bản "91" thành số 91.
Khi một tệp chỉ gồm các số hoặc từ cách nhau bằng dấu cách, hasNextInt() và nextInt() đọc từng token (một mảnh giữa các dấu cách hoặc ngắt dòng) mỗi lần, không cần tách. Cái bẫy ký tự xuống dòng còn sót khi dùng nextInt rồi nextLine với đầu vào bàn phím cũng áp dụng cho tệp.
Bây giờ là cái bẫy mà gần như ai cũng vấp một lần:
Tệp data.txt chứa:
42
import java.util.Scanner;
public class ScanTrap {
public static void main(String[] args) {
Scanner in = new Scanner("data.txt");
System.out.println(in.nextLine());
}
}
data.txt
new Scanner("data.txt") không phải là một tệp. Nó là một Scanner đang đọc String "data.txt", dài tám ký tự. Nó vui vẻ trả về các ký tự đó, và không bao giờ nhìn vào data.txt thật hay số 42 bên trong. Để đọc tệp, bạn phải bọc tên trong một đối tượng File: new Scanner(new File("data.txt")).
Đọc bằng BufferedReader#
BufferedReader là cách phổ biến còn lại để đọc văn bản. Hãy bọc nó quanh một FileReader. Nó có một phương thức chính, readLine(), trả về dòng kế tiếp, hoặc null khi tệp đã hết:
Tệp poem.txt chứa:
Roses are red
Violets are blue
Files must be closed
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class ReadBuffered {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new FileReader("poem.txt"));
String line;
int number = 0, blank = 0;
while ((line = in.readLine()) != null) {
number++;
if (line.isEmpty()) {
blank++;
} else {
System.out.println(number + ": " + line);
}
}
in.close();
System.out.println(number + " lines, " + blank + " blank");
}
}
1: Roses are red
3: Violets are blue
4: Files must be closed
4 lines, 1 blank
Vòng lặp đọc một dòng vào line và kiểm tra nó với null trong một bước: while ((line = in.readLine()) != null). Cặp ngoặc thừa làm cho phép gán xảy ra trước. Đây là vòng lặp BufferedReader chuẩn, đáng để nhận ra ngay khi thấy.
Scanner hay BufferedReader: dùng cái nào và vì sao#
Chữ “buffered” trong BufferedReader chính là điểm mấu chốt. Nó kéo một khối lớn của tệp vào bộ nhớ mỗi lần, mặc định 8.192 ký tự, và đưa cho bạn từng dòng từ khối đó, nên nó ít phải đi chậm xuống đĩa. Scanner cũng dùng bộ đệm, nhưng nó tốn thêm công sức để tách văn bản thành token và kiểm tra kiểu của chúng.
Scanner | BufferedReader | |
|---|---|---|
| Đọc | dòng và token: nextInt, nextDouble, next | chỉ nguyên dòng: readLine |
| Chuyển đổi số giúp bạn | có | không: dùng Integer.parseInt và các hàm tương tự |
| Tốc độ với tệp lớn | chậm hơn | nhanh hơn |
| Lỗi khi đọc | che giấu chúng; hãy kiểm tra ioException() | ném IOException để bạn biết |
| Cuối tệp | hasNextLine() là false | readLine() trả về null |
Dùng Scanner cho tệp nhỏ, và bất cứ khi nào nội dung là hỗn hợp từ và số mà bạn muốn chuyển đổi khi đọc. Đừng dùng nó cho tệp rất lớn, nơi tốc độ của nó gây hại, hoặc khi bạn cần biết rằng một lần đọc đã thất bại. Dùng BufferedReader cho tệp lớn và xử lý từng dòng, chấp nhận rằng bạn tự chuyển đổi các số.
Xử lý ngoại lệ về tệp#
Các thao tác với tệp ném ngoại lệ checked, nên trình biên dịch không cho bạn bỏ qua. Hai ngoại lệ cần biết là FileNotFoundException, khi tệp cần đọc không tồn tại (hoặc không mở được), và lớp cha của nó IOException, cho bất cứ điều gì khác sai khi đọc hoặc ghi.
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class Missing {
public static int countLines(String name) {
int count = 0;
try (Scanner in = new Scanner(new File(name))) {
while (in.hasNextLine()) {
in.nextLine();
count++;
}
} catch (FileNotFoundException e) {
System.out.println("Could not open " + name + ", counting 0 lines");
}
return count;
}
public static void main(String[] args) {
System.out.println(countLines("missing.txt"));
System.out.println("The program is still running");
System.out.println(new File("missing.txt").exists());
}
}
Could not open missing.txt, counting 0 lines
0
The program is still running
false
Chương trình không sập: catch biến một tệp bị thiếu thành một thông báo rõ ràng, và việc thực thi tiếp tục. Khi một khối có thể ném cả hai ngoại lệ tệp, quy tắc của bài hướng dẫn về ngoại lệ áp dụng: bắt FileNotFoundException, lớp con, trước IOException, lớp cha của nó. (Nội dung của e.getMessage() khác nhau giữa Windows và các hệ thống khác, đó là lý do đoạn mã này in thông báo của riêng nó.)
Một tệp mà chương trình khăng khăng là bị thiếu, trong khi bạn thấy nó trong thư mục, hầu như luôn là vấn đề đường dẫn. Một tên đơn thuần, không kèm thư mục, như "data.txt" là một đường dẫn tương đối: Java tìm nó trong thư mục làm việc của chương trình, thư mục mà chương trình được khởi động từ đó. Trong BlueJ và VS Code đó thường là thư mục dự án, không phải thư mục src. new File("data.txt").getAbsolutePath() in ra chính xác Java đang tìm ở đâu, và exists() cho bạn biết có gì ở đó không.
Mở, dùng, đóng: ghi bằng PrintWriter bọc quanh FileWriter (thêm true để nối thêm), đọc bằng Scanner(new File(name)) hoặc BufferedReader, và đóng mọi tệp, tốt nhất bằng try-with-resources. Ngoại lệ về tệp là checked, nên hãy bắt chúng hoặc khai báo chúng.
Những chỗ dễ sai#
- Không bao giờ đóng writer. Văn bản trong bộ đệm có thể không bao giờ đến đĩa, để lại một tệp rỗng.
new Scanner("data.txt"). Cách đó đọc chính String. Hãy viếtnew Scanner(new File("data.txt")).- Mở một tệp có sẵn bằng
new FileWriter(name)khi bạn muốn nối thêm vào nó. Nó bị làm rỗng trước. Hãy dùngnew FileWriter(name, true). - Quên các ngoại lệ checked. Không có
catchhoặc mệnh đềthrows, mã không biên dịch được. - Bắt
IOExceptiontrướcFileNotFoundException. Lớp con phải đứng trước nếu không catch thứ hai sẽ không bao giờ đến được. - Kiểm tra
readLine()có là String rỗng để tìm chỗ kết thúc. Một dòng trống là""; cuối tệp lànull. - Đặt tệp dữ liệu trong thư mục
src. Đường dẫn tương đối được tìm từ thư mục làm việc, thường là thư mục dự án.
Luyện tập#
Hãy trả lời từng câu trên giấy trước khi xem lời giải. Mọi đáp án có chạy mã đều đã được kiểm tra bằng cách biên dịch và chạy mã đó.
- Sự khác nhau giữa
new FileWriter("log.txt")vànew FileWriter("log.txt", true)là gì khilog.txtđã có văn bản bên trong? - Một chương trình ghi ba dòng bằng
PrintWriter, không bao giờ gọiclose(), và tệp ra rỗng. Hãy giải thích vì sao, và nêu hai cách sửa. - Một tệp
numbers.txtchứa các số nguyên cách nhau bằng dấu cách và ngắt dòng. Hãy viết một chương trình in tổng của chúng, có xử lý trường hợp tệp bị thiếu. - Hãy nêu một tình huống mà
Scannerlà lựa chọn tốt hơn và một tình huống màBufferedReadertốt hơn, kèm lý do. - Hãy viết một chương trình sao chép
in.txtsangout.txtvới mọi dòng viết hoa, dùngBufferedReadervàPrintWriter. - Chương trình của bạn ném
FileNotFoundExceptionchodata.txt, nhưng bạn thấy tệp đó trong dự án. Nguyên nhân có khả năng nhất là gì, và dòng nào sẽ cho bạn thấy?
Lời giải#
- Cái đầu làm rỗng tệp và bắt đầu ghi từ đầu. Cái thứ hai mở nó ở chế độ nối thêm, nên văn bản mới được thêm vào sau những gì đã có.
PrintWritergiữ văn bản trong bộ đệm và gửi xuống đĩa theo từng đợt; đợt đó chưa bao giờ được gửi vì writer chưa bao giờ được đóng (hoặc flush). Cách sửa: gọiout.close()khi xong, hoặc mở writer bằng try-with-resources để nó tự động được đóng.- Đọc từng token bằng
hasNextIntvànextInt; với một tệp chứa 4 8 15 16 23 42:Tệp
numbers.txtchứa:4 8 15 16 23 42import java.io.File; import java.io.FileNotFoundException; import java.util.Scanner; public class QSum { public static void main(String[] args) { int sum = 0; try (Scanner in = new Scanner(new File("numbers.txt"))) { while (in.hasNextInt()) { sum += in.nextInt(); } } catch (FileNotFoundException e) { System.out.println("numbers.txt is missing"); } System.out.println("Sum: " + sum); } }Sum: 108 Scanner: một tệp nhỏ trộn lẫn từ và số, vì nó chuyển đổi token khi đọc.BufferedReader: một tệp nhật ký rất lớn được xử lý từng dòng, vì nó đọc các khối lớn mỗi lần và nhanh hơn, và nó báo lỗi đọc dưới dạngIOExceptionthay vì che giấu chúng.- Cả hai tệp được mở trong một try-with-resources, cách nhau bằng dấu chấm phẩy, nên cả hai được đóng tự động:
Tệp
in.txtchứa:one two threeimport java.io.BufferedReader; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; public class QCopy { public static void main(String[] args) { try (BufferedReader in = new BufferedReader(new FileReader("in.txt")); PrintWriter out = new PrintWriter(new FileWriter("out.txt"))) { String line; while ((line = in.readLine()) != null) { out.println(line.toUpperCase()); } } catch (IOException e) { System.out.println("Copy failed: " + e.getMessage()); } try (BufferedReader check = new BufferedReader(new FileReader("out.txt"))) { String line; while ((line = check.readLine()) != null) { System.out.println(line); } } catch (IOException e) { System.out.println("Could not read the copy"); } } }ONE TWO THREE - Đường dẫn tương đối đang được tìm từ thư mục làm việc, còn tệp nằm ở chỗ khác, chẳng hạn bên trong
src.System.out.println(new File("data.txt").getAbsolutePath());in ra vị trí chính xác mà Java đang kiểm tra.
Danh sách kiểm tra trước khi thi#
Đây là các mục trong danh sách chủ đề Bài thi 2 của môn học mà bài hướng dẫn này đề cập. Chỉ đánh dấu mỗi mục khi bạn làm được mà không cần nhìn.
- ☐ Tôi có thể mở một tệp để ghi và để đọc, và giải thích luồng là gì.
- ☐ Tôi có thể ghi vào một tệp bằng
PrintWritervàFileWriter, kể cả ghi nối thêm. - ☐ Tôi có thể đọc từ một tệp bằng
Scannervà bằngBufferedReader, và giải thích vì sao nên dùngBufferedReader. - ☐ Tôi có thể nói khi nào nên dùng lớp
Scannervà khi nào không. - ☐ Tôi có thể đóng một tệp, và giải thích vì sao việc đóng quan trọng, kể cả try-with-resources.
- ☐ Tôi có thể xử lý các ngoại lệ về tệp:
FileNotFoundExceptionvàIOException.
Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí
40 câu luyện tập về đọc và ghi tệp bằng Scanner, BufferedReader và FileWriter, với mọi đáp án mã đều được kiểm tra bằng cách biên dịch và chạy. Miễn phí, dùng ngoại tuyến, không cần tài khoản.
Câu hỏi thường gặp#
Làm thế nào để ghi vào một tệp văn bản trong Java?
Tạo một PrintWriter bọc quanh một FileWriter, chẳng hạn new PrintWriter(new FileWriter("out.txt")), rồi dùng print, println hoặc printf, và đóng nó khi xong. Truyền true làm đối số thứ hai cho FileWriter để ghi nối thêm thay vì ghi đè. Mở tệp có thể ném IOException, phải được bắt hoặc khai báo.
Làm thế nào để đọc một tệp văn bản trong Java?
Hoặc tạo một Scanner bọc quanh một đối tượng File, new Scanner(new File("data.txt")), rồi lặp, gọi nextLine() chừng nào hasNextLine() còn trả về true; hoặc tạo một BufferedReader bọc quanh một FileReader và lặp trong khi readLine() không trả về null.
Vì sao tôi nên dùng BufferedReader thay vì Scanner?
BufferedReader đọc từng khối lớn của tệp vào bộ nhớ mỗi lần và trả về nguyên từng dòng, nên nhanh hơn với tệp lớn, và nó báo lỗi đọc dưới dạng IOException. Scanner tiện hơn cho tệp nhỏ vì nó tách văn bản thành các token và chuyển đổi số, nhưng chậm hơn và che giấu lỗi đọc.
Vì sao tệp đầu ra của tôi bị rỗng?
Rất có thể là writer chưa bao giờ được đóng. PrintWriter và FileWriter giữ văn bản trong bộ nhớ đệm và chỉ gửi xuống đĩa khi bộ đệm đầy, khi gọi flush(), hoặc khi tệp được đóng. Hãy gọi close(), hoặc mở writer bằng try-with-resources.
try-with-resources là gì?
Một dạng của try mở một hoặc nhiều tài nguyên, chẳng hạn tệp, trong dấu ngoặc đơn sau từ khóa try. Java tự động đóng chúng khi khối kết thúc, kể cả khi có ngoại lệ bị ném. Nó có thể dùng mà không có khối catch hoặc finally.
Vì sao Java nói không tìm thấy tệp của tôi trong khi nó có tồn tại?
Tên tệp không có thư mục là một đường dẫn tương đối, được tìm từ thư mục làm việc của chương trình, thường là thư mục dự án chứ không phải thư mục src. Hãy in new File("name.txt").getAbsolutePath() để thấy chính xác Java đang tìm ở đâu.
Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.